Dec 13-15, 2017 Vikrant Patil
These notes are available online at http://notes.pipal.in/2017/vmware-nov-python
© Pipal Academy LLP
problem:
csvparser which parses data written in csv format and loads it in memory as 2 dimensional list.def csvparser(filename):
return [line.split(",") for line in open(filename)]
csvparser("data1.csv")
with open("numbers.txt", "a") as f:
f.write("ten\n")
f.write("nine\n")
import cat
cat.cat(["numbers.txt"])
Lets make our parsers and writers generic
def genericparser(file, delimiter=","):
return [line.strip().split(delimiter) for line in open(file)]
def genericwriter(data, filename, delimiter=","):
with open(filename, "w") as fhandle:
for row in data:
fhandle.write(delimiter.join(row) + "\n")
data = [[str(i*j) for i in range(1,11)] for j in range(1,6)]
data
genericwriter(data, "tables.tsv", delimiter="\t")
!python cat.py tables.tsv
how do you transpose data?
data[0] # 0th row
data[0][0] # item from 0th row and 0th column
#data[rownumber][columnnumber]
[data[rownumber][0] for rownumber in range(len(data))]
[data[rownumber][1] for rownumber in range(len(data))]
rows = len(data)
cols = len(data[0])
data
[data[rownum][0] for rownum in range(rows)]
[data[rownum][1] for rownum in range(rows)]
[[data[rownum][colnum] for rownum in range(rows)] for colnum in range(cols) ]
def transpose(data):
rows = len(data)
cols = len(data[0])
return [[data[rownum][colnum] for rownum in range(rows)] for colnum in range(cols) ]
genericwriter(transpose(data), "tables.tsv", delimiter="\t")
!python cat.py tables.tsv
genericparser("tables.tsv", delimiter="\t")
csvparser = lambda filename: genericparser(filename, delimiter=",")
csvparser("data1.csv")
def csvparser(filename):
return genericparser(filename, delimiter=",")
import sys
sys.stdout.write("Hello this is just output!")
sys.stderr.write("Something went wrong !!")
person = {"name":"lewis carrol",
"books":["ALice in wonderland", "Looking through the glass"],
"language":"English"}
person['name']
person['name'] = "lewis"
person
del person['language']
person
person['language']
person.get("language", "english")
person.get("name", "unknown")
person['books'][0]
person['books'][1]
grub conf on my laptop looks like this
!python cat.py /etc/default/grub
def confreader(file):
data = {}
for line in open(file):
if line.startswith("#") or line.strip()=="":
continue
items = line.strip().split("=")
data[items[0]] = "".join(items[1:])
return data
confreader("/etc/default/grub")
confdata = confreader("/etc/default/grub")
confdata['GRUB_CMDLINE_LINUX_DEFAULT']
digits = [("one",1), ("two",2), ("three",3)]
dict(digits)
names = ["Anand", "Nouful", "David", "Lewis", "Ronbinson"]
place = ["India", "India", "USA", "UK", "USA"]
d = dict(zip(names, place))
for item in d:
print(item)
for key in d.keys():
print(key, d[key])
for value in d.values():
print(value)
for key,value in d.items():
print(key, value)
items = ["Pencil", "Colorbox", "Pen", "Eraser"]
prices = [10, 25, 12, 5]
cart = dict(zip(items, prices))
cart
for item, price in cart.items():
print(item.rjust(10), price)
print("-"*20)
print("Total".rjust(10), sum(cart.values()))
problem :
%%file words.txt
one
one two
one two three
one two three four
one two three four five
one two three four five six
six seven eight nine ten
seven eight nine ten
eight nine ten
nine ten
ten
d
"alice" in ["alice", "alex"]
"Anand" in d
"Anand" in d.keys()
"India" in d.values()
def getwords(filename):
return open(filename).read().split()
words = getwords("words.txt")
words
def wordfreq(words):
freq = {}
for word in words:
if word in freq:
freq[word] += 1
else:
freq[word] = 1
return freq
wordfreq(words)
def wordfreq1(words):
freq = {}
for w in words:
freq[w] = freq.get(w, 0) + 1
return freq
wordfreq1(words)
def wordfreq2(words):
freq = {}
unique = set(words)
for w in unique:
freq[w] = words.count(w)
return freq
def wordfreq3(words):
freq = dict(zip(words, [0]*len(words)))
for w in words:
freq[w] += 1
return freq
wordfreq3(words)
freq = wordfreq3(words)
for key in freq:
print(key, freq[key])
for key in sorted(freq):
print(key, freq[key])
for key in sorted(freq, key=lambda k:freq[k]):
print(key, freq[key])
for key in sorted(freq, key=lambda k:freq[k], reverse=True):
print(key, freq[key])
for key in sorted(freq, key=lambda k:freq[k], reverse=True):
print(key.rjust(6), "*"*freq[key])
d
[ name for name,place in d.items() if place=="India"]
[ name for name,place in d.items() if place=="USA"]
x = [1,2,3,4]
y = x
y.append(5)
print(x)
x = [1,2,3,4,5]
y = x
x = [1,2,3]
print(y)
d.keys()
d.values()
def unzip(data):
keys = list(data.keys())
values = [data[k] for k in keys]
return keys, values
unzip(d)
class Complex:
def __init__(self, real, imag):
self.real = real
self.imag = imag
def get_real(self):
return self.real
def get_imag(self):
return self.imag
def display(self):
print(self.real ,"+", str(self.imag)+"j")
def add(self, c):
pass
Complex
print(Complex)
c1 = Complex(2,3)
c1
c1.get_imag()
c1.get_real()
c1.display()
isinstance(c1, Complex)
class Complex:
def __init__(self, real, imag):
self.real = real
self.imag = imag
def get_real(self):
return self.real
def get_imag(self):
return self.imag
def display(self):
print(self.real ,"+", str(self.imag)+"j")
def add(self, c):
return Complex(self.real+c.real, self.imag+c.imag)
def double(self):
return Complex(2*self.real, 2*self.imag)
c = Complex(1,2)
c2 = c.double()
c2.display()
c.display()
c3 = c.add(c2)
c3.display()
%%file module1.py
x = 10
def getx():
return x
def getdouble():
return 2*x
%%file module2.py
x = 10
def getx():
print("from module2")
return x
def getdouble():
print("from module2")
return 2*x
import module1
import module2
module1.x
module2.x
module2.x = 20
module2.getx()
%%file bank0.py
balance = 0
def get_balance():
return balance
def withdraw(amount):
global balance
balance = balance - amount
def deposite(amount):
global balance
balance += amount
if __name__ == "__main__":
deposite(100)
print(get_balance())
withdraw(20)
print(get_balance())
!python bank0.py
%%file bank1.py
def create_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
if __name__ == "__main__":
a1 = create_account()
a2 = create_account()
deposit(a1, 100)
deposit(a2, 200)
print("a1 : ", get_balance(a1))
print("a2 : ", get_balance(a2))
withdraw(a1, 10)
withdraw(a2, 20)
print("a1 : ", get_balance(a1))
print("a2 : ", get_balance(a2))
!python bank1.py
%%file bank2.py
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
if __name__ == "__main__":
a1 = BankAccount()
a2 = BankAccount()
a1.deposit(100)
a2.deposit(200)
print("a1 : ", a1.get_balance())
print("a2 : ", a2.get_balance())
a1.withdraw(10)
a2.withdraw(20)
print("a1 : ", a1.get_balance())
print("a2 : ", a2.get_balance())
!python bank2.py
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
p = Point(1, 2)
p.x
p.y
p.z = 3
p.z
p.x
p.y
p.__dict__
class ColoredPoint(Point):
color = (0,0,0) #rgb
cp = ColoredPoint(2, 3)
cp.color
cp.x
cp.y
cp.__dict__
type(ColoredPoint)
type(cp)
ColoredPoint.__dict__
cp.__dict__
problem:
t = Timer()
t.start()
do some stuff (may a loop with some calculations)
t.stop()
print(t.get_time_taken())import time
time.time()
import time
class Timer:
def __init__(self):
self._start = 0
self._end = 0
def start(self):
self._start = time.time()
def stop(self):
self._end = time.time()
def get_time_taken(self):
return self._end - self._start
t = Timer()
t.start()
s = 0
for i in range(1000):
for j in range(10000):
s += i*j*1.0
t.stop()
print("{0:.3f}".format(t.get_time_taken()))
x + 2
2 + "3"
doom
int("hello")
try:
a = int("dfdf")
except ValueError as e:
print("Handled ValueError", e)
a = 0
a
%%file missing.csv
1,2,3,4,5,Nan
1,2,3,4,5,6
1,,3,2,4,5
Nan,1,1,1,1,1
csvparser("missing.csv")
def parsenumerccsv(filename):
data = []
for line in open(filename):
items = line.strip().split(",")
data.append([int(i) for i in items])
return data
parsenumerccsv("missing.csv")
def parsenumerccsv(filename):
def parseint(s):
try:
return int(s)
except ValueError as e:
return 0
data = []
for line in open(filename):
items = line.strip().split(",")
data.append([parseint(i) for i in items])
return data
parsenumerccsv("missing.csv")
try:
x = int(s)
except ValueError as v:
pass
except NameError as n:
pass
except TypeError as t:
pass
%%file grep.py
import argparse
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("pattern",
type=str,
help="pattern to be serched")
parser.add_argument("filename",
type=str,
help="file in which pattern has to be searched")
return parser.parse_args()
if __name__ == "__main__":
args = parse_args()
print(args)
!python grep.py "def" bank2.py
%%file grep.py
import argparse
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("pattern",
type=str,
help="pattern to be serched")
parser.add_argument("filename",
type=str,
help="file in which pattern has to be searched")
return parser.parse_args()
def grep(pattern, filename):
for line in open(filename):
if pattern in line:
print(line.strip())
if __name__ == "__main__":
args = parse_args()
print(args)
grep(args.pattern, args.filename)
!python grep.py def bank2.py
!python grep.py --help
%%file grep.py
import argparse
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("pattern",
type=str,
help="pattern to be serched")
parser.add_argument("filename",
type=str,
help="file in which pattern has to be searched")
parser.add_argument("-v", "--invert_match",
action="store_true",
help="lines which do not have given pattern")
return parser.parse_args()
def grep(pattern, filename):
for line in open(filename):
if pattern in line:
print(line.strip())
def grep_invert(pattern, filename):
for line in open(filename):
if pattern not in line:
print(line.strip())
if __name__ == "__main__":
args = parse_args()
print(args)
if args.invert_match:
grep_invert(args.pattern, args.filename)
else:
grep(args.pattern, args.filename)
!python grep.py -h
!python grep.py -v balance bank0.py
%%file grep.py
import argparse
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("pattern",
type=str,
help="pattern to be serched")
parser.add_argument("filename",
type=str,
help="file in which pattern has to be searched")
parser.add_argument("-v", "--invert_match",
action="store_true",
help="lines which do not have given pattern")
parser.add_argument("-b", "--backcontext",
type=int,
help="number of context lines to be printed")
return parser.parse_args()
def grep(pattern, filename):
for line in open(filename):
if pattern in line:
print(line.strip())
def grep_invert(pattern, filename):
for line in open(filename):
if pattern not in line:
print(line.strip())
if __name__ == "__main__":
args = parse_args()
print(args)
if args.invert_match:
grep_invert(args.pattern, args.filename)
else:
grep(args.pattern, args.filename)
!python grep.py -h
!python grep.py -b 5 def bank0.py
problem:
python fib.py 3
2
python fib.py -s 6
1 1 2 3 5 8import requests
resp = requests.get("http://httpbin.org/get", params={"param1":1, "param2":"2"})
resp.status_code
resp.text[:50]
resp.text
resp.json()
resp = requests.post("http://httpbin.org/post", data={"name":"python", "param":"hello"})
resp.json()
resp = requests.post("http://httpbin.org/post", data="Plain text data")
resp.json()
resp = requests.post("http://httpbin.org/post", data=open("data1.csv"))
resp.json()
url = "https://api.github.com/orgs/vmware/repos"
resp = requests.get(url)
repos = resp.json()
type(repos)
len(repos)
print(repos[0]['forks'])
for r in repos:
print(r['name'], r['forks'])
def get_forks(repo):
return repo['forks']
for repo in sorted(repos, key=get_forks, reverse=True)[:5]:
print(repo['name'], repo['forks'])
problem:
distance("bangalore", "pune")
800kmdef 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['rows'][0]['elements'][0]['distance']['text']
distance("bangalore", "pune")
import json
s = json.dumps({"data":[1,2,3,{"x":"y"}]})
s
json.loads(s)