Basic Python Training at Arcesium - Day 2¶
Sep 23-24, 2019 Vikrant Patil
These notes are available online at http://notes.pipal.in/2019/arcesium_basic_sep/day1.html
© Pipal Academy LLP
We will be using python 3 (>= 3.0) from anaconda for this training. You can download it from
bonus problems
- Write a list comprehension to generate 5x5 unit matrix. a unit matrix is a matrix with diagonal element as 1 evry other element is 0
- Write an expression to sum all multiples of 7 or 11 less than 1000
- Write a function to rodate 2D list 90 degrees clockwise
- Write a function to find sum of digits of given integer
>>> sumdigits(1111) 4
In [7]:
d = {True:1, False:0}
I = [[d[i==j] for i in range(5)] for j in range(5)]
I
Out[7]:
In [2]:
sum([i for i in range(1000) if i%7==0 or i%11==0])
Out[2]:
In [9]:
def column(data, c):
return [data[r][c] for r in range(len(data))]
def reversedcolumn(data, c):
return [data[r][c] for r in reversed(range(len(data)))]
In [10]:
def rotate90(data):
colcount = len(data[0])
return [reversedcolumn(data, c) for c in range(colcount)]
In [11]:
rotate90(I)
Out[11]:
In [12]:
print(__name__)
Sring formating¶
In [13]:
for i in range(1, 11):
print(i, i*i, i**3)
In [14]:
for i in range(1, 11):
print(str(i).rjust(2), str(i*i).rjust(3), str(i**3).rjust(4))
In [16]:
w = 4
for i in range(1, 11):
print(str(i).rjust(w), str(i*i).rjust(w), str(i**3).rjust(w))
In [17]:
htmltemplate ="""
<html>
<header>
{HEADER}
</header
<body>
<p>
{CONTENTS}
</p>
</body>
</html>
"""
In [18]:
import this
In [19]:
poem = """
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
"""
In [20]:
html = htmltemplate.format(HEADER="Zen of Python", CONTENTS=poem)
In [21]:
print(html)
In [23]:
"{} of oz is {}".format("Wizard", "Python")
Out[23]:
In [24]:
"{1} of oz is {0}".format("Wizard", "Python")
Out[24]:
In [25]:
"{wizard} of oz is {somebody}".format(wizard="Wizard", somebody="Python")
Out[25]:
In [26]:
import jason
In [27]:
import json
In [28]:
json.dumps(I)
Out[28]:
In [30]:
d = {"data":I, "attr1":"hello"}
In [31]:
d
Out[31]:
In [33]:
jsonstring = json.dumps(d)
In [34]:
jsonstring
Out[34]:
In [35]:
json.loads(jsonstring)
Out[35]:
problems
- Write a function to generate pascal triangle
>>> pascal(4) [[1],[1,1],[1,2,1],[1,3,3,1]] - Write a function to pretty print a triangle of
** * * * * * * * * * * * * * *
bonus
- Write a function to pretty print pascal trianlge
In [36]:
r = [1, 2, 1]
In [37]:
r1 = r[:]
r2 = r[:]
In [38]:
r1
Out[38]:
In [39]:
r2
Out[39]:
In [40]:
r1.append(0)
r2.insert(0, 0)
In [41]:
r1
Out[41]:
In [42]:
r2
Out[42]:
In [43]:
[i+j for i,j in zip(r1, r2)]
Out[43]:
In [44]:
def nextrow(r):
r1 = r[:]
r2 = r[:]
r1 = r1 + [0]
r2 = [0] + r2
return [x+y for x,y in zip(r1, r2)]
In [45]:
nextrow([1])
Out[45]:
In [46]:
def pascal(n):
t = [[1]]
for i in range(n-1):
prev = t[-1]
nextr = nextrow(prev)
t.append(nextr)
return t
In [47]:
pascal(5)
Out[47]:
In [48]:
pascal(6)
Out[48]:
In [49]:
"*"*5
Out[49]:
In [50]:
["*"]*5
Out[50]:
In [51]:
def triangle(base, char="*"):
return [ [char]*i for i in range(1, base+1)]
In [52]:
triangle(6)
Out[52]:
In [53]:
def createrowstr(row):
return " ".join(row)
def pretty_print(triangle):
n = len(triangle[-1])
width = n + (n-1) # n for items, n-1 for spaces
for row in triangle:
line = createrowstr(row).center(width)
print(line)
In [56]:
def pretty_print(triangle(30))
In [58]:
def totext(data):
return [[str(item) for item in row] for row in data]
pretty_print(totext(pascal(5)))
In [59]:
pretty_print(totext(pascal(6)))
Working with files¶
In [60]:
%%file poem.txt
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
In [62]:
with open("poem.txt") as f:
print(f.read())
In [64]:
with open("poem.txt") as f:
for line in f:
print(line, end="")
In [65]:
with open("poem.txt") as f:
for i, line in enumerate(f):
print(i+1, line, end="")
In [66]:
f = open("poem.txt")
In [67]:
f.readline()
Out[67]:
In [68]:
f.readline()
Out[68]:
In [69]:
f.readline()
Out[69]:
In [70]:
f.readlines()
Out[70]:
In [71]:
for line in f:
print(line, end="")
In [72]:
r = reversed(range(5))
In [73]:
for i in r:
print(i)
In [74]:
for i in r:
print(i)
problems
- Write a python script
cat.pywhich prints contents of file to standard output - Write a python script
head.pywhich prints first n lines of file.
python head.py 3 poem.txt
The Zen of Python, by Tim Peters
Beautiful is better than ugly.- Write a python script
wc.pywhich mimics unix command wc. it should show linecount, wordcount and charcount.
python wc.py poem.txt
21 144 857 poem.txt- Write a python script
tail.pywhich shows last n lines of file.
python tail.py 3 poem.txt
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!- Find longest line from file.
In [75]:
!wc poem.txt
In [76]:
!cat poem.txt
In [78]:
!head -n 5 poem.txt
In [79]:
!tail -n 5 poem.txt
In [80]:
%%file cat.py
import sys
def cat(filename):
with open(filename)as f:
print(f.read())
if __name__ == "__main__":
cat(sys.argv[1])
In [83]:
%%file head.py
import sys
def head(n, filename):
with open(filename) as f:
for i in range(n):
print(f.readline(), end="")
if __name__ == "__main__":
head(int(sys.argv[1]), sys.argv[2])
In [84]:
!python head.py 3 poem.txt
In [85]:
%%file wc.py
import sys
def linecount(file):
with open(file) as f:
return len(f.readlines())
def wordcount(file):
with open(file) as f:
return len(f.read().strip().split())
def charcount(file):
with open(file) as f:
return len(f.read())
if __name__ == "__main__":
f = sys.argv[1]
print(linecount(f), wordcount(f), charcount(f), f)
In [86]:
!python wc.py poem.txt
In [87]:
l = [1, 2, 3, 4, 5, 6, 7, 8]
In [88]:
l[2:]
Out[88]:
In [89]:
l[:5]
Out[89]:
In [90]:
l[:-3]
Out[90]:
In [91]:
l[-3:]
Out[91]:
In [92]:
n = len(l)
In [93]:
l[3-n:]
Out[93]:
In [94]:
l[-3:]
Out[94]:
In [103]:
%%file tail.py
import sys
def tail(file, n):
with open(file) as f:
lines = f.readlines()
for line in lines[-n:]:
print(line, end="")
def efficient_tail(file, n):
with open(file) as f:
window = [""]*n
for line in f:
window.append(line)
window.pop(0)
for line in window:
print(line, end="")
if __name__ == "__main__":
file = sys.argv[2]
n = int(sys.argv[1])
efficient_tail(file, n)
In [104]:
!python tail.py 4 poem.txt
In [102]:
l.pop?
different modes of opening file¶
"w" -> Write text->
"a" -> append text
"b" -> binary
"rb" -> read binary
"wb" -> write binary->In [105]:
with open("numbers.txt", "w") as f:
f.write("one\n")
f.write("tow\n")
f.write("three\n")
In [106]:
!python cat.py numbers.txt
In [109]:
with open("numbers.txt", "w") as f: # this will over write existing contents
f.write("one\n")
f.write("two\n")
f.write("three\n")
In [110]:
!python cat.py numbers.txt
In [111]:
with open("numbers.txt", "a") as f:
f.write("four\n")
f.write("five\n")
In [112]:
!python cat.py numbers.txt
In [113]:
b'four'
Out[113]:
Working with dictionary¶
In [115]:
person = {"name":"Alice",
"email":"alice@wonder.land",
"language":"english"
}
In [116]:
person['name']
Out[116]:
In [117]:
person['country']
In [118]:
person.get("country","UK")
Out[118]:
In [119]:
person
Out[119]:
In [120]:
del person['email']
In [121]:
person
Out[121]:
In [122]:
person['email'] = "alice@wonder.land"
Example - Word frequency¶
In [123]:
%%file words.txt
one
one two
one two three
one two three four
one two three four five
one two three four six
one two three six seven
one two six seven eight
one six seven eight nine
six seven eight nine ten
six seven eight nine
six seven eight
six seven
six
In [124]:
def wordfreq(words):
freq = {}
for w in words:
if w in freq:
freq[w] += 1
else:
freq[w] = 1
return freq
In [125]:
def getwords(file):
with open(file) as f:
return f.read().strip().split()
In [126]:
words = getwords("words.txt")
In [127]:
wordfreq(words)
Out[127]:
In [128]:
def wordfreq1(words):
freq = {}
for w in words:
freq[w] = freq.get(w, 0) + 1
return freq
In [129]:
wordfreq1(words)
Out[129]:
In [130]:
def wordfreq2(words):
unique = set(words)
freq = {}
for w in unique:
freq[w] = words.count(w)
return freq
In [131]:
wordfreq2(words)
Out[131]:
In [133]:
def wordfreq3(words):
unique = set(words)
return {w:words.count(w) for w in unique}
In [135]:
wordfreq3(words)
Out[135]:
In [137]:
freq = wordfreq(words)
In [138]:
for w in sorted(freq):
print(w, freq[w])
In [140]:
for w in sorted(freq, key=lambda w: freq[w], reverse=True):
print(w, freq[w])
In [141]:
for w in sorted(freq, key=lambda w: freq[w], reverse=True):
print(w.rjust(5), freq[w])
In [142]:
for w in sorted(freq, key=lambda w: freq[w], reverse=True):
print(w.rjust(5), freq[w], freq[w]*"*")
In [143]:
for w in freq:
print(w)
In [144]:
for w,f in freq.items():
print(w.rjust(5), f, f*"*")
In [146]:
for f in freq.values():
print(f, end=",")
In [148]:
sorted([1, 2, 3, 4, 5], key=lambda x: 5)
Out[148]:
In [149]:
names = ['Elsa',"Alex","Alice","Elisa"]
surnames = ["Frozen", "Lion","Wonder","Hacker"]
dict(zip(names, surnames))
Out[149]:
problem
- Read a config file given below and load it as dictionary.
>>> loadconfig("config.cfg") {"processor":"Corei5","os":"Mint","memory":"16GB"}
In [150]:
%%file config.cfg
processor=Corei5
os=mint
memory=16GB
In [151]:
def loadconfig(file):
with open(file) as f:
conf = {}
for line in f:
k,v = line.strip().split("=")
conf[k] = v
return conf
In [152]:
loadconfig("config.cfg")
Out[152]:
In [153]:
def loadconfig(file):
with open(file) as f:
return dict([line.strip().split("=") for line in f])
In [154]:
loadconfig("config.cfg")
Out[154]:
In [155]:
def loadconfig(file):
with open(file) as f:
return {k:v for k,v in [line.strip().split("=") for line in f]}
In [156]:
loadconfig("config.cfg")
Out[156]:
In [157]:
tables = [[i*j for i in range(1,6)] for j in range(1,11)]
In [158]:
tables
Out[158]:
problems
- Write a function
writecsvto write csv file for tabular data.%%file data.csv 1,2,3,4,5 2,4,6,8,10 . . . - Write a function
parsecsvto read csv file and load data as 2D list of integers
In [163]:
def writecsv(data, file):
with open(file, "w") as f:
for row in data:
line = ",".join([str(item) for item in row])
f.write(line)
f.write("\n")
In [164]:
writecsv(tables, "tables.csv")
In [165]:
!python cat.py tables.csv
In [166]:
def parsecsv(file):
with open(file) as f:
data = []
for line in f:
items = line.strip().split(",")
data.append([int(i) for i in items])
return data
In [167]:
parsecsv("tables.csv")
Out[167]:
environment¶
In [168]:
a = 10
def foo():
a = 20
print(a)
In [170]:
x = [1, 1, 1, 0]
def foo():
x = [0,0,0]
foo()
print(x)
In [171]:
x = [1, 1, 1]
def foo():
x.append(0)
foo()
print(x)
In [172]:
x = [1, 1, 1]
def foo():
x = x + [1]
foo()
print(x)
In [173]:
x = [1, 1, 1]
def foo():
x = [1]
foo()
print(x)
In [ ]:
x = [1, 1, 1]
def foo(y):
y.append(0)
foo(x)
print(x)
classes¶
In [174]:
%%file bank.py
balance = 0
def withdraw(amount):
global balance
balance -= amount
def deposit(amount):
global balance
balance += amount
def get_balance():
return balance
if __name__ == "__main__":
pass
In [175]:
import bank
In [176]:
bank.get_balance()
Out[176]:
In [177]:
bank.deposit(10000)
In [178]:
bank.withdraw(2323)
In [179]:
bank.get_balance()
Out[179]:
In [180]:
%%file bank1.py
def make_account():
return {"balance":0}
def get_balance(account):
return account['balance']
def withdraw(account, amount):
account['balance'] -= amount
def deposit(account, amount):
account['balance'] += amount
In [181]:
import bank1
In [182]:
a1 = bank1.make_account()
In [183]:
a2 = bank1.make_account()
In [184]:
bank1.deposit(a1, 10000)
bank1.deposit(a2, 2000)
In [185]:
bank1.withdraw(a1, 2323)
In [186]:
print(bank1.get_balance(a1))
print(bank1.get_balance(a2))
In [187]:
class BankAccount:
def __init__(self):
self.balance = 0
def get_balance(self):
return self.balance
def deposit(self, amount):
self.balance += amount
def withdraw(self, amount):
self.balance -= amount
In [188]:
a1 = BankAccount()
In [189]:
a1.get_balance()
Out[189]:
In [190]:
a1.deposit(10000)
In [191]:
a1.withdraw(3243)
In [192]:
a1.get_balance()
Out[192]:
In [193]:
a2 = BankAccount()
In [194]:
a2.deposit(23323)
In [195]:
a1.balance
Out[195]:
In [196]:
a2.balance
Out[196]:
In [197]:
class BankAccount:
def __init__(self):
self._balance = 0 # a convention for private attribute
def get_balance(self):
return self.balance
def deposit(self, amount):
self.balance += amount
def withdraw(self, amount):
self.balance -= amount
In [198]:
a1 = BankAccount()
In [199]:
a1._balance
Out[199]:
In [200]:
a1.__dict__
Out[200]:
In [201]:
class Foo:
pass
In [202]:
f = Foo()
In [203]:
f.x = 10
In [204]:
f.x
Out[204]:
inheritance¶
In [205]:
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
class RedPoint(Point):
color = "red"
In [206]:
p = Point(3, 4)
In [207]:
r1 = RedPoint(0, 0)
In [208]:
p.x,p.y
Out[208]:
In [209]:
r1.x, r1.y
Out[209]:
In [210]:
r1.color
Out[210]:
In [211]:
r2 = RedPoint(5,6)
In [212]:
r2.color
Out[212]:
In [213]:
RedPoint.color
Out[213]:
In [214]:
RedPoint.color = "RED"
In [215]:
r1.color
Out[215]:
In [216]:
r2.color
Out[216]:
In [217]:
r2.color = "red"
In [218]:
RedPoint
Out[218]:
In [219]:
r1.color
Out[219]:
In [220]:
RedPoint.color
Out[220]:
In [221]:
r1.__dict__
Out[221]:
In [222]:
r2.__dict__
Out[222]:
problem
- Write a class
Timerwhich will have following methods, start, stop, elapsed_timet = Timer() t.start() task() t.stop() print("Time taken by taks:", t.elapsed_time()) `
In [223]:
import time
In [224]:
time.time()
Out[224]:
In [228]:
class Timer:
def start(self):
self._start = time.time()
def stop(self):
self._end = time.time()
def reset(self):
self._start = 0
self._end = 0
def elapsed_time(self):
return self._end - self._start
In [229]:
t = Timer()
t.start()
time.sleep(2)
t.stop()
print("Time taken:",t.elapsed_time())
In [230]:
l
Out[230]:
In [231]:
str(l)
Out[231]:
In [232]:
class Pair:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return "Pair({},{})".format(self.x, self.y)
def __str__(self):
return "<{},{}>".format(self.x, self.y)
In [233]:
p = Pair(2,3)
In [234]:
p
Out[234]:
In [235]:
r1
Out[235]:
In [237]:
Point(0,0)
Out[237]:
In [238]:
print(p)
In [239]:
class Pair:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return "Pair({},{})".format(self.x, self.y)
def __str__(self):
return "<{},{}>".format(self.x, self.y)
def __add__(self, p):
return Pair(self.x + p.x , self.y + p.y)
def __eq__(self, p):
return self.x==p.x and self.y==p.y
In [240]:
p1 = Pair(3,4)
In [241]:
p2 = Pair(5,6)
In [242]:
p1 + p2
Out[242]:
In [243]:
p1 == p2
Out[243]:
In [244]:
p3 = Pair(3, 4)
In [245]:
p1 == p3
Out[245]:
In [246]:
p = Point(3, 4)
In [247]:
p
Out[247]:
In [248]:
type(p)
Out[248]:
In [249]:
type(p1)
Out[249]:
In [250]:
isinstance(p1, Pair)
Out[250]:
In [251]:
isinstance(p, Point)
Out[251]:
In [252]:
isinstance(r1, Point)
Out[252]:
In [253]:
class Pair:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return "Pair({},{})".format(self.x, self.y)
def __str__(self):
return "<{},{}>".format(self.x, self.y)
def __add__(self, p):
return Pair(self.x + p.x , self.y + p.y)
def __eq__(self, p):
return self.x==p.x and self.y==p.y
def __getitem__(self, name):
if name == "x":
return self.x
elif name == "y":
return self.y
else:
raise KeyError("No such item", name)
In [254]:
p = Pair(4,5)
In [256]:
p['x']
Out[256]:
In [257]:
p['y']
Out[257]:
In [258]:
p['z']
In [260]:
type(1)
Out[260]:
Example : shape modeling¶
In [264]:
%matplotlib inline
In [278]:
from functools import reduce
from matplotlib.pyplot import imshow
class Shape:
def contains(self, p):
pass
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
class Rectangle(Shape):
def __init__(self, width, length):
self.w = width
self.l = length
def contains(self, p):
return p.x <= self.w and p.y <= self.l
class Circle(Shape):
def __init__(self, radius):
self.r = radius
def contains(self, p):
return (p.x**2 + p.y**2)**0.5 <= self.r
class Union(Shape):
def __init__(self, shapes):
self.shapes = shapes
def contains(self, p):
conds = [s.contains(p) for s in self.shapes]
return reduce(lambda x,y: x or y, conds, False)
class Intersection(Shape):
def __init__(self, shapes):
self.shapes = shapes
def contains(self, p):
conds = [s.contains(p) for s in self.shapes]
return reduce(lambda x,y: x and y, conds, True)
class Canvas:
def __init__(self, w=1000, l=1000):
self.w = w
self.l = l
self.display = [[False for i in range(w)] for j in range(l)]
def draw(self, shape):
def translate(p):
return Point(self.w//2 - p.x, self.l//2 -p.y)
self.display = [[shape.contains(translate(Point(i,j))) for i in range(self.w)] for j in range(self.l)]
def plot(self):
imshow(self.display)
In [279]:
c = Circle(50)
canvas = Canvas(100,100)
canvas.draw(c)
canvas.plot()
In [280]:
c1 = Circle(50)
r1 = Rectangle(10, 120)
u = Union([c1, r1])
inter = Intersection([c1, r1])
In [281]:
canvas = Canvas(200, 200)
canvas.draw(u)
canvas.plot()
In [282]:
canvas = Canvas(200, 200)
canvas.draw(inter)
canvas.plot()
Further references¶
- Google for Python Practice Book Anand Chitipothu
- google for python docs
- Python Data Science Handbook
In [283]:
import openpyxl
In [ ]: