Python Training at VMWare - Day 3¶
Jan 29-31, 2018 Vikrant Patil
These notes are available online at http://notes.pipal.in/2018/vmware-pune-jan-python
© Pipal Academy LLP
Writing files¶
In [1]:
f = open("numbers.txt", "w")
f.write("ones\n")
f.write("two\n")
f.write("three\n")
Out[1]:
In [2]:
f.close()
In [3]:
!python cat.py numbers.txt
In [5]:
with open("primes.txt", "w") as f:
f.write("two\n")
f.write("three\n")
f.write("five\n")
print("Here ends with block")
In [6]:
!python cat.py primes.txt
In [7]:
with open("primes.txt", "a") as f:
f.write("seven\n")
f.write("eleven\n")
In [8]:
!python cat.py primes.txt
In [9]:
with open("binary.bin", "wb") as f:
f.write(b"\x23\x2a")
f.write(b"string as binary data\n")
In [10]:
with open("binary.bin", "rb") as f:
print(f.read())
In [12]:
with open("regional.txt", "w", encoding="utf-8") as f:
f.write("आआडढ\n")
f.write("\u0c65")
In [13]:
with open("regional.txt", encoding="utf-8") as f:
print(f.read())
Example¶
Writing a csv file
In [14]:
t = [[i*j for i in range(1,11)] for j in range(1,5)]
In [15]:
t
Out[15]:
In [19]:
def writecsv(data, filename):
with open(filename, "w") as csv:
for row in data:
csv.write(",".join([str(item) for item in row]))
csv.write("\n")
In [20]:
writecsv(t, "tables.csv")
In [21]:
!python cat.py tables.csv
problem
- write a csvparser to load numeric data from csv file to a 2d list.
- Can you make it generic where in you also specify the delimiter.
In [22]:
l = []
l[0] = 3
In [23]:
numbers = ["1","2","3","4","5","6"]
In [24]:
[int(item) for item in numbers]
Out[24]:
In [25]:
def csvparser(filename):
data = []
with open(filename) as f:
for line in f:
row_ = line.strip().split(",")
row = [int(i) for i in row_]
data.append(row)
return data
In [26]:
csvparser("tables.csv")
Out[26]:
In [28]:
[[int(i) for i in line.strip().split(",")] for line in open("tables.csv")]
Out[28]:
In [29]:
def csvparser(filename):
return [[int(i) for i in line.strip().split(",")] for line in open(filename)]
In [33]:
def csvparser(filename):
return [[int(i) for i in line.strip().split(",")] for line in open(filename)]
In [30]:
csvparser("tables.csv")
Out[30]:
In [31]:
def csvparser(filename):
data = []
with open(filename) as f:
line = f.readline()
while line:
row_ = line.strip().split(",")
row = [int(i) for i in row_]
data.append(row)
line = f.readline()
return data
In [32]:
csvparser("tables.csv")
Out[32]:
writing to stderr and stdout¶
In [34]:
import sys
sys.stderr.write("Something went wrong!")
In [35]:
sys.stdout.write("Just a print")
Dictionaries¶
In [ ]:
In [36]:
author = {"name":"Lewis carol",
"books":["Alice in wonderland","Looking through the glass"],
"language":"english"}
In [37]:
author['name']
Out[37]:
In [38]:
author['books']
Out[38]:
In [39]:
author['language']="english-uk"
In [40]:
author
Out[40]:
In [41]:
del author["language"]
In [42]:
author
Out[42]:
In [43]:
author['books'][1]
Out[43]:
In [44]:
"name" in author
Out[44]:
In [45]:
"lagguage" in author
Out[45]:
In [46]:
author['xyz']
In [47]:
author.get("key",[])
Out[47]:
In [48]:
author.get("key",2)
Out[48]:
In [49]:
author
Out[49]:
In [50]:
author['key'] = "hello"
In [51]:
type(author)
Out[51]:
In [52]:
isinstance(author,dict)
Out[52]:
In [54]:
author.get("xyz",None)
In [60]:
delattr(author ,"Lewis carol")
In [61]:
author
Out[61]:
In [62]:
help(delattr)
In [63]:
d = {}
names = ["Anand","Naufal","David","Alice"]
countries = ["India","India","USA","UK"]
In [64]:
for name,country in zip(names, countries):
d[name] = country
In [65]:
d
Out[65]:
In [66]:
items = [1,2,3,4]
In [67]:
item[4]= 5
In [68]:
d["Alex"] = "USA"
In [69]:
d
Out[69]:
In [70]:
dict(zip(names, countries))
Out[70]:
Example¶
load grub conf as dictinary
In [71]:
!python cat.py /etc/default/grub
In [79]:
def load_grubconf(filename):
conf = {}
for line in open(filename):
if line.startswith("#") or line.strip()=="" or ("=" not in line):
continue
tokens = line.strip().split("=",1)
conf[tokens[0]] = tokens[1]
return conf
In [80]:
load_grubconf("/etc/default/grub")
Out[80]:
problem
- Write a function to find frquency of all words from given file
In [77]:
%%file words.txt
one
one two
one two three
one two three four
one two three four five
one two three four five six
one two three four five
one two three four
one two three
one two
one
In [78]:
"a:".split(":")
Out[78]:
In [81]:
def wordfreq(filename):
words = open(filename).read().strip().split()
freq = {}
for word in words:
freq[word] = freq.get(word,0) + 1
return freq
In [82]:
wordfreq("words.txt")
Out[82]:
In [83]:
def wordfreq(filename):
words = open(filename).read().strip().split()
uniq = set(words)
freq = {}
for w in uniq:
freq[w] = words.count(w)
return freq
Iterating over dictionaries¶
In [84]:
freq = wordfreq("words.txt")
In [85]:
for item in freq:
print(item, freq[item])
In [86]:
for item in freq:
print(item)
In [88]:
for key,value in freq.items():
print(key, value)
In [89]:
for value in freq.values():
print(value)
In [90]:
for item in freq.keys():
print(item)
In [91]:
for key,value in freq.items():
print(key.rjust(5), str(value).ljust(2))
In [92]:
for key,value in sorted(freq.items()):
print(key.rjust(5), str(value).ljust(2))
In [94]:
for key in sorted(freq, key=lambda x:freq[x]):
print(key.rjust(5), str(freq[key]).ljust(2))
In [95]:
for key in sorted(freq, key=lambda x:freq[x], reverse=True):
print(key.rjust(5), str(freq[key]).ljust(2))
In [98]:
sorted(freq, key=lambda x:freq[x], reverse=True)
Out[98]:
In [99]:
for key in sorted(freq, key=lambda x:freq[x], reverse=True):
print(key.rjust(5), str(freq[key]).ljust(2), "*"*freq[key])
In [100]:
d
Out[100]:
In [102]:
v = set(d.values())
In [105]:
[key for key in d if d[key]=="India"] #group all keys based on values
Out[105]:
In [106]:
[key for key in d if d[key]=="USA"]
Out[106]:
In [110]:
for item in v:
print([key for key in d if d[key]==item])
pitfalls¶
In [111]:
x = [1,2,3]
y = x
y.append(4)
x
Out[111]:
In [112]:
x
Out[112]:
In [113]:
y
Out[113]:
In [114]:
x = [1,2,3]
y = x
x = [1,1]
y
Out[114]:
In [115]:
y = x[:]
In [116]:
y
Out[116]:
In [117]:
x = [1,2,3]
y = x[:]
y.append(4)
x
Out[117]:
Why classes¶
In [118]:
%%file module1.py
x = 5
y = 3
def addx(z):
return x+z
def addy(z):
return y+z
In [119]:
import module1
In [120]:
module1.x
Out[120]:
In [121]:
module1.y
Out[121]:
In [122]:
module1.x = 0
In [123]:
module1.x
Out[123]:
In [124]:
%%file bank0.py
balance = 0
def getbalnce():
return balance
def deposite(amount):
global balance
balance += amount
def withdraw(amount):
global balance
balance -= amount
if __name__ == "__main__":
print(getbalnce())
deposite(100)
print(getbalnce())
withdraw(23)
print(getbalnce())
In [125]:
!python bank0.py
In [126]:
%%file bank1.py
def make_account():
return {"balance":0}
def get_balance(account):
return account['balance']
def deposite(account, amount):
account['balance'] += amount
def withdraw(account, amount):
account['balance'] -= amount
if __name__ == "__main__":
def print_(a1, a2):
print("a1: ",get_balance(a1))
print("a2: ",get_balance(a2))
a1 = make_account()
a2 = make_account()
print_(a1, a2)
deposite(a1, 1000)
deposite(a2, 1100)
print_(a1,a2)
withdraw(a1, 244)
withdraw(a2, 300)
print_(a1, a2)
In [128]:
!python bank1.py
In [129]:
module1.z = 3
In [130]:
%%file bank2.py
class BankAccount:
def __init__(self, balance=0):
self.balance = balance
def get_balance(self):
return self.balance
def deposite(self, amount):
self.balance += amount
def withdraw(self, amount):
self.balance -= amount
def hello():
print("Hello")
if __name__ == "__main__":
a1 = BankAccount()
a2 = BankAccount(300)
print("a1: ", a1.get_balance())
print("a2: ", a2.get_balance())
In [131]:
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
In [133]:
p = Point(1,2)
In [134]:
p.x
Out[134]:
In [135]:
p.y
Out[135]:
In [136]:
def add(x,y):
return x+y
In [137]:
class Foo:
pass
In [138]:
Foo
Out[138]:
In [139]:
type(Foo)
Out[139]:
In [140]:
type(p)
Out[140]:
In [141]:
p.__dict__
Out[141]:
In [142]:
p.z = 3
In [143]:
p.z
Out[143]:
In [144]:
p.__dict__
Out[144]:
In [145]:
Foo.__dict__
Out[145]:
In [146]:
def f():
pass
In [147]:
f()
In [148]:
p.newfunc = f
In [149]:
del p.x
In [150]:
p.x
problem
- Write a class Timer, which can be used to to time a task. make use of time.time()
t = Timer()
t.start()
s = 0
for i in range(1000):
for j in range(10000):
s += i*j*1.0
t.stop()
print(t.get_time_taken())In [151]:
import time
In [152]:
time.time()
Out[152]:
In [194]:
class Complex:
def __init__(self, real, img):
self.real = real
self.img = img
def add(self, c):
return Complex(self.real+c.real, self.img+c.img)
def _display(self):
return "{r}+{i}j".format(r=self.real, i=self.img)
def __repr__(self):
return "Complex({r},{i})".format(r=self.real, i=self.img)
def __str__(self):
return self._display()
In [195]:
c = Complex(2,3)
In [196]:
help(Complex)
In [197]:
c._display()
Out[197]:
In [198]:
c1 = Complex(3,4)
In [199]:
c2 = c.add(c1)
In [200]:
c2._display()
Out[200]:
In [201]:
print(c) ## coming from __str__
In [204]:
c # coming from __repr__
Out[204]:
In [164]:
class Timer:
def start(self):
self._start = time.time()
def stop(self):
self._stop = time.time()
def get_time_taken(self):
return self._stop - self._start
In [165]:
t = Timer()
In [166]:
t.start()
In [167]:
time.sleep(2)
In [168]:
t.stop()
In [169]:
t.get_time_taken()
Out[169]:
In [170]:
t
Out[170]:
In [205]:
class Foo:
pass
class Foo(object):
pass
In [206]:
class ColoredPoint(Point):
def __init__(self, x, y, color=(0,0,0)):
Point.__init__(self, x, y)
self.color = color
In [207]:
item = [1,2,3,4]
In [208]:
item
Out[208]:
In [209]:
import this
In [210]:
a
In [211]:
c
Out[211]:
Example¶
In [235]:
import math
import matplotlib.pyplot as plt
%matplotlib inline
def imshow(img):
plt.imshow(img, cmap=plt.cm.gray)
plt.show()
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
class Shape:
position = Point(0,0)
def contains(self, point):
pass
def distance(p1, p2):
dx = p2.x - p1.x
dy = p2.y - p1.y
return math.sqrt(dx**2 + dy**2)
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def contains(self, p):
return distance(p, self.position)<=self.radius
class Recangle(Shape):
def __init__(self, length, width):
self.length = length
self.width = width
def contains(self, point):
dx = point.x - self.position.x
dy = point.y - self.position.y
return dx<=self.width and dy<=self.length
class Intersect(Shape):
def __init__(self, shapes):
self.shapes = shapes
def contains(self, point):
flag = True
for s in self.shapes:
flag = flag and s.contains(point)
return flag
class Union(Shape):
def __init__(self, shapes):
self.shapes = shapes
def contains(self, point):
flag = False
for s in self.shapes:
flag = flag or s.contains(point)
return flag
class Canvas:
def __init__(self, x=200, y=200):
self.x = x
self.y = y
self.data = [[False for i in range(x)] for j in range(y)]
def paint(self, shape):
for i in range(self.y):
for j in range(self.x):
self.data[i][j] = shape.contains(Point(i,j))
def display(self):
imshow(self.data)
In [221]:
c = Circle(20)
In [222]:
canvas = Canvas()
In [223]:
canvas.paint(c)
In [224]:
canvas.display()
In [228]:
r = Recangle(100,50)
In [229]:
canvas.paint(r)
In [230]:
canvas.display()
In [234]:
s = [Circle(50),Recangle(,100)]
intersect = Intersect(s)
c = Canvas()
c.paint(intersect)
c.display()
In [237]:
s = [Circle(50),Recangle(20,100)]
u = Union(s)
c = Canvas()
c.paint(u)
c.display()
Exceptions¶
In [238]:
%%file missing.txt
1,2,3,4,5,6,,8,9,10
2,4,6,8,10,Nan,14,16,18,20
3,6,9,12,15,18,21,24,27,30
4,8,12,16,20,24,,32,36,40
In [239]:
csvparser("missing.txt")
In [252]:
import sys
def parseint(strnm):
try:
return int(strnm)
except ValueError as v:
sys.stderr.write(str(v))
return 0
In [253]:
def csvparser(filename):
return [[parseint(v) for v in line.strip().split(",")] for line in open(filename)]
In [254]:
csvparser("missing.txt")
Out[254]:
building commandline applications¶
In [272]:
%%file head.py
import argparse
def head(filename, lines=5):
f = open(filename)
for i in range(lines):
print(f.readline().strip())
def parse_arguments():
parser = argparse.ArgumentParser(
description="head command shows first few lines of file")
# if only one name given it is
parser.add_argument("filename", type=str,
help="File whose contents are to be shown")
#if long and short name is given then this is optional
parser.add_argument("-n", "--lines", type=int,
help="number of lines to show")
return parser.parse_args()
if __name__ == "__main__":
args = parse_arguments()
print(args)
if args.lines:
head(args.filename, args.lines)
else:
head(args.filename)
In [273]:
!python head.py
In [274]:
!python head.py -h
In [275]:
!python head.py data.txt
In [276]:
!python head.py -n 10 data.txt
In [278]:
!python head.py -n xsx data.txt
In [289]:
%%file grep.py
import argparse
def grep(pattern, filename):
for line in open(filename):
if pattern in line:
print(line, end="")
def invertgrep(pattern, filename):
for line in open(filename):
if pattern not in line:
print(line, end="")
def parse_arguments():
parser = argparse.ArgumentParser(
description="grep command greps for given patters in a file")
# if only one name given it is
parser.add_argument("pattern", type=str,
help="pattern to search")
parser.add_argument("filename", type=str,
help="File in which to look for pattern")
#if long and short name is given then this is optional
parser.add_argument("-v", "--invert",
help="Invert the match",
action="store_true")
return parser.parse_args()
if __name__ == "__main__":
args = parse_arguments()
if args.invert:
invertgrep(args.pattern, args.filename)
else:
grep(args.pattern, args.filename)
In [290]:
!python grep.py "def" head.py
In [291]:
!python grep.py -v "def" head.py
working with web api¶
In [292]:
import requests
install requests using
pip3 install requestsIn [293]:
resp = requests.get("http://httpbin.org/html")
In [294]:
print(resp.text[:100])
In [295]:
resp.status_code
Out[295]:
In [296]:
resp = requests.get("http://httpbin.org/get", params={"param1":"python",
"param2":"xyz"})
In [297]:
print(resp.text)
In [298]:
resp = requests.post("http://httpbin.org/post", data={"name":"python",
"email":"xyz@xyz.com"})
In [299]:
print(resp.text)
In [300]:
resp = requests.post("http://httpbin.org/post", data=open("numbers.txt"))
In [301]:
print(resp.text)
In [302]:
resp.json()
Out[302]:
Example¶
Find popular repositories of vmware on github
In [303]:
url = "https://api.github.com/orgs/vmware/repos"
repos = requests.get(url).json()
In [305]:
type(repos)
Out[305]:
In [306]:
len(repos)
Out[306]:
In [307]:
print(repos[0])
In [308]:
def get_forks(r):
return r['forks']
for r in sorted(repos, key=get_forks, reverse=True):
print(r['name'], r['forks'])
In [324]:
for r in sorted(repos, key=get_forks, reverse=True)[:5]:
print(r['full_name'], r['forks'])
In [321]:
def get_top_contributors(name):
url = "https://api.github.com/repos/{}/stats/contributors".format(name)
resp = requests.get(url)
print(resp.status_code)
contributors = resp.json()
return contributors
In [325]:
contribs = get_top_contributors("vmware/pyvmomi")
In [326]:
type(contribs)
Out[326]:
In [333]:
c = contribs[0]['author']
print(c['login'], contribs[0]['total'])
In [334]:
for c in sorted(contribs, key=lambda x:x['total'], reverse=True)[:5]:
print(c['author']['login'], c['total'])
problem find distance between two cities using google api.
- url for ditance is "https://maps.googleapis.com/maps/api/distancematrix/json/"
- parameters are
origins destinations units - metric
In [353]:
def distance(source, dest):
url = "https://maps.googleapis.com/maps/api/distancematrix/json/"
resp = requests.get(url, params={"origins":source,
"destinations":dest,
"units":"metric"})
data = resp.json()
return data
In [354]:
distance("pune", "mumbai")
References¶
Suggested mini projects.
- directorytree - print directory tree
- testing
- backup scripts
- sockets , try to create your own simple httpserver
In [ ]: