Oct 22-24, 2018 Vikrant Patil
These notes are available online at http://notes.pipal.in/2018/arcesium-advanced-oct/day1.html
© Pipal Academy LLP
We will be using python 3 (>= 3.0) from anaconda for this training. You can download it from
digits = [0,1,2,3,4,5,6,7,8,9]
digits[0]
digits[-1]
digits[2:4]
digits[:2] #take first two
x = [1,2,3]
y = [-1,-2,-3]
z = [0]*5
a = [1]*5
collection = [x,y,z,a]
subview = collection[1:2]
subview
collection
subview
[collection[1]]
y.append(-4)
y
collection
subview
digits[2:]# drop first two
digits[:2] = []
digits
list(range(10))
list(range(2,10))
list(range(2,10,2))
digits[2:9:2]
digits = list(range(10))
digits[2:9:2]
digits[::2]
digits[::-1]
problem
digits[2:5:-1]
digits[8:3:-1]
def is_palindrome(word):
return word == word[::-1]
is_palindrome("madam")
for i in range(0,10,1):
print(i, end=",")
squares = []
for d in digits:
squares.append(d*d)
squares
[d*d for d in squares]
def even(x):
return x%2==0
squares = []
for d in digits:
if even(d):
squares.append(d*d)
squares
[d*d for d in digits if even(d)]
[e for e in digits if even(e)]
problem
data = [[1,1,1],
[2,2,2],
[3,3,3]]
data
data[0]
data[-1]
data[0][0]
data[0][1]
data[0][2]
data[0]
row0 = data[0]
row0[0]
def column(data, n):
return [row[n] for row in data]
column(data, 0)
problem
def transpose(data):
cols = len(data[0])
return [column(data, c) for c in range(cols)]
transpose(data)
data
if data:
print("List is nonempty")
else:
pass
%%file data.csv
A1,A2,A3
B1,B2,B3
C1,C2,C3
csvdata = []
with open("data.csv") as csv:
for line in csv:
csvdata.append(line.strip().split(","))
csvdata
csvdata
def csvparser(filename):
with open(filename) as f:
return [line.strip().split(",") for line in f]
csvparser("data.csv")
def quick(data):
if not data:
return []
pivot = data[0]
less = [n for n in data[1:] if n < pivot]
greater = [n for n in data[1:] if n>= pivot]
return quick(less) + [pivot] + quick(greater)
quick([2,5,1,7,9,2,34,3,4])
sorted([2,3,4,1,6,23,56])
Positional arguments work by position. you can not misplace the order of arguments
def cylinder_volume(radius, height):
return 3.14*radius**2*height
cylinder_volume(1,1)
cylinder_volume(1,10)
cylinder_volume(10, 1) # if arguments are given in different order you get different result
def cylinder_volume(radius, height):
return 3.14*radius**2*height
cylinder_volume(radius=1.0, height=10)
cylinder_volume(height=10, radius=1.0)
def cylinder_volume(radius=1.0, height=1.0):
return 3.14*radius**2*height
cylinder_volume()
list(range(10))
import os
os.listdir()
os.listdir("/tmp/")
import random
def jitter(n, delta=random.random()):
return n+delta
random.random()
for item in [100, 101, 125, 130]:
print(jitter(item))
def jitter(n, delta=None):
if not delta:
delta = random.random()
return n+delta
for item in [100, 101, 125, 130]:
print(jitter(item))
Even if you want to have muttable objects as default arguments , initialize it to None
def append(value, collection=None):
if not collection:
collection = []
collection.append(value)
return collection
x = [1,2,3]
append(10,collection=x)
x
append(11)
def add(a=0, b):
return a+b
def adder(x=5, y =3):
return x+y
adder()
adder(2)
adder(y=5)
def foo(x,y, *, name="bar"):
pass
foo(2,3)
foo(2,3,"python")
foo(2,3,name="python")
def foo(x,y, *, data="bar"):
pass
foo(1,2,data="xyz")
foo(1,2,bar=3)
def foo (x,y,data="bar"):
pass
foo(2,3,"python")
def fun(*, x, y, data="bar"):
pass
fun(x=1,y=3)
fun(1,3)
import os.path
os.path.join("/","home","vikrant")
"_".join(["A","B","C"])
os.path.join("/","home","vikrant","trainings")
def myjoin(*args):
sep = "/"
return sep.join(args)
myjoin("z","y","z")
d = ["a","b","c","d"]
myjoin(d)
myjoin(*d)
def make_person(**metadata):
print(type(metadata))
person = {}
for key, value in metadata.items():
person[key] = value
return person
make_person(name="python", email="python@python.org", web="www.python.org")
def fun():
print("fun!")
print(fun)
x = 2
print(x)
y = x
aliasfun = fun
print(aliasfun)
fun
aliasfun
fun()
aliasfun()
def square(x):
return x*x
def sumofsquares(x,y):
return square(x) + square(y)
def cube(x):
return x*x*x
def sumofcubes(x,y):
return cube(x) + cube(y)
def sumof(f, x, y):
return f(x) + f(y)
sumof(square, 3, 5)
sumofsquares(3,5)
max([3,4,5,1,78,32])
words = ["one","two","three","four","five"]
max(words)
max(words, key=len)
sorted(words)
sorted(words, key=len)
def sumf(f, start, end):
s = 0
for i in range(start, end):
s += f(i)
return s
8/1*3 + 8/5*7 + 8/9*11 ..... this series slowly converges to pidef f(n):
return 8/((4*n-3)*(4*n-1))
sumf(f, 1, 1000)
def make_adder(x):
def adder(y):
return x+y
return adder
adder5 = make_adder(5)
adder5
adder5(8)
adder5(3)
adder7 = make_adder(7)
adder7(5)
adder7(8)
add = lambda x, y: x+y
add(3,4)
sumf(lambda n: 8/((4*n-3)*(4*n-1)), 1, 1000)
problems
repeat which applies given function n times.repeat_ which returns a function which when called is equivalent to calling a function n times.def repeat(f, n, arg):
res = f(arg)
for i in range(n-1):
res = f(res)
return res
def repeat_(f, n):
def repeter(x):
for i in range(n):
x = f(x)
return x
return repeter
def add(x, y):
return x+y
def debug(f):
def wrapper(*args):
print("Begining ", f.__qualname__, args)
r = f(*args)
print("Returning", r)
return r
return wrapper
add_ = debug(add)
add_(2,3)
add = debug(add)
add(3,4)
@debug
def square(x):
return x*x
def sumofsquares(x, y):
return square(x) + square(y)
sumofsquares(5,6)
(1,)
(1,2)
(1,)*2
level = 0
def trace(f):
def wrapper(*args):
global level
print(" |"*level + "-" + f.__qualname__, *args)
level += 1
r = f(*args)
print(" |"*level + "-return", r)
level -=1
return r
return wrapper
@trace
def square(x):
return x*x
@trace
def sumofsquares(x,y):
return square(x) + square(y)
sumofsquares(5,6)
def fib(n):
if n in [1,2]:
return 1
else:
return fib(n-1) + fib(n-2)
for i in range(1,10):
print(fib(i), end=",")
@trace
def fib(n):
if n in [1,2]:
return 1
else:
return fib(n-1) + fib(n-2)
fib(5)
fib(8)
problem
deprecated which displays depricated warning message when the function is calledtimeit which will time given function call use time.time() to get current timestampwith_retries which calls given function five times before giving up!import time
def timeit(f):
def wrapper(*args):
start = time.time()
r = f(*args)
print("Time taken:",time.time()-start)
return r
return wrapper
def fib_(n):
if n in [1,2]:
return 1
else:
return fib_(n-1) + fib_(n-2)
@timeit
def fibcaller(n):
return fib_(n)
fibcaller(35)
%%file memoize.py
from functools import wraps
def memoize(f):
cache = {}
@wraps(f)
def wrapper(*args):
if args not in cache:
cache[args] = f(*args)
return cache[args]
return wrapper
import imp
imp.reload(memoize)
import memoize
@memoize.memoize
def square(x):
print("Calling square", x)
return x*x
def sumofsquares(x,y):
return square(x) + square(y)
sumofsquares(2,3)
sumofsquares(3,2)
@trace
@memoize.memoize
def fib1(n):
if n in [1,2]:
return 1
else:
return fib1(n-1) + fib1(n-2)
fib1(8)
fib(8)
@memoize.memoize
def fib1(n):
if n in [1,2]:
return 1
else:
return fib1(n-1) + fib1(n-2)
@timeit
def fibcaller(n):
return fib1(n)
fibcaller(35)
fibcaller(50)
from functools import wraps
def with_retries(f):
@wraps(f)
def wrapper(*args):
for i in range(5):
try:
return f(*args)
except Exception as e:
print(e, "retrying...", i+1)
print("Giving up!")
return wrapper
import requests
@with_retries
def download(url):
r = requests.get(url)
return r.status_code==200
download("http://xyz.skjdlkaslsbd.dkjfhkjsd.com/dsd")
from functools import wraps
def with_retries(tries=5):
def _with_retries(f):
@wraps(f)
def wrapper(*args):
for i in range(tries):
try:
return f(*args)
except Exception as e:
print(e, "retrying...", i+1)
print("Giving up!")
return wrapper
return _with_retries
@with_retries(tries=3)
def download(url):
r = requests.get(url)
return r.status_code==200
download("http://hsjhdkasj")
import json
jsonstring = json.dumps({"name":"alice", "email":"alice@wonder.land"})
jsonstring
json.loads(jsonstring)
import requests
url = "https://api.github.com/orgs/{}/repos".format("google")
url
repos = requests.get(url).json()
type(repos)
len(repos)
repos[0]
for r in repos:
print(r['full_name'], r['forks'])
def get_forks(r):
return r['forks']
for r in sorted(repos, key=get_forks, reverse=True)[:5]:
print(r['name'], r['forks'])
url = "http://www.thehindu.com/"
response = requests.get(url, params={"service":"rss"})
xmltext = response.text
print(xmltext[:100])
from xml.etree import ElementTree as et
root = et.fromstring(xmltext)
items = root.findall(".//item")
len(items)
items[0]
print(et.tostring(items[0]).decode())
for item in items[:10]:
print(item.findtext("title"))
print(item.findtext("link"))
print("--"*20)
from xml.dom.minidom import parseString
root = parseString(xmltext)
root
items = root.getElementsByTagName("item")
len(items)
item = items[0]
title = item.getElementsByTagName("title")[0]
title.firstChild.data
for item in items[:10]:
title = item.getElementsByTagName("title")[0]
link = item.getElementsByTagName("link")[0]
print(title.firstChild.data)
print(link.firstChild.data)
print("-"*10)
import sqlite3
conn = sqlite3.connect("data.db") #:memory:
cur = conn.cursor()
cur.execute("create table person (name varchar(100), email varchar(100))")
cur.execute("insert into person(name, email) values('alice', 'alice@wonder.land')")
cur = cur.execute("select * from person")
cur.fetchall()
def find_person(conn , email):
q = "select * from person where email='{}'".format(email)
cur = conn.cursor()
return cur.execute(q).fetchall()
find_person(conn, "alice@wonder.land")
def find_person(conn , email):
q = "select * from person where email=?"
cur = conn.cursor()
return cur.execute(q, (email,)).fetchall()
find_person(conn, "alice@wonder.land")
cur.close()
cur.execute("select * from person")
cur = conn.cursor()
cur.execute("select * from person")
cur = conn.cursor()
q = "select * from person where email like ?"
cur.execute(q, ("%alice%",)).fetchall()
from sqlalchemy import Table , Column, Integer, String, MetaData, ForeignKey, create_engine
metadata = MetaData()
users = Table('users', metadata,
Column('id', Integer, primary_key=True),
Column('name', String),
Column("email", String))
posts = Table("posts", metadata,
Column('id', Integer, primary_key=True),
Column("author_id", Integer, ForeignKey('users.id')),
Column("title", String),
Column("body", String))
engine = create_engine("sqlite:///test.db", echo=True)
metadata.create_all(engine)
q = users.insert().values(name="Alice", email="alice@wonder.land")
metadata.bind = engine
q.execute()
results = users.select().execute()
results.fetchall()
select = users.select()
select.where(users.columns.name=="Alice").execute().fetchall()
from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey, create_engine
from sqlalchemy.ext.declarative import declarative_base
engine = create_engine("sqlite:///test.db")
Base = declarative_base()
Base.metadata.bind = engine
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True)
name = Column(String)
email = Column(String)
def __repr__(self):
return "User({0},{1})".format(self.name, self.email)
class Post(Base):
__tablename__ = "posts"
id = Column(Integer, primary_key=True)
author_id = Column(Integer, ForeignKey("users.id"))
title = Column(String)
body = Column(String)
def __repr__(self):
return "Post({author}, {title})".format(author=self.author_id, title=self.title)
from sqlalchemy.orm import sessionmaker
DBSession = sessionmaker(bind=engine)
session = DBSession()
new_user = User(name="anand", email="anand@xyz.com")
session.add(new_user)
session.commit()
q = session.query(User)
print(q.all())