Övning 1. Abstrakta datatyper. 1. Stacken. class Stack: """A representation of a last-in-first-out (LIFO) stack of objects."""

Transkript

1 Per Sedholm DD1320 (tilda12) Övning 1 Abstrakta datatyper 1. Stacken #!/usr/bin/python3 # -*- coding: utf-8 -*- """Classroom exercise 1, example 1.""" class Stack: """A representation of a last-in-first-out (LIFO) stack of objects.""" def init (self): """Create an empty stack.""" self.top = None def push(self,x): """Push an item onto the top of this stack.""" ny = Node(x) ny.next = self.top self.top = ny def pop(self): """Remove the top object from this stack and return it.""" x = self.top.value self.top = self.top.next return x def isempty(self): """Test if this stack is empty.""" ## The naïve solution (below) is unnecessary: # if self.top == None: # return True # else: # return False return self.top == None class Node: """An entry in a linked structure (e.g. Stack).""" def init (self, x): """Create a node linked to the given element.""" self.value = x self.next = None 1

2 $ python3 -i ovn1-01.py >>> help(stack) Help on class Stack in module main : class Stack(builtins.object) A representation of a last-in-first-out (LIFO) stack of objects. Methods defined here: init (self) Create an empty stack. isempty(self) Test if this stack is empty. pop(self) Remove the top object from this stack and return it. push(self, x) Push an item onto the top of this stack. >>> help(node) Help on class Node in module main : class Node(builtins.object) An entry in a linked structure (e.g. Stack). Methods defined here: init (self, x) Create a node linked to the given element. Användning data = "pining for the fjords" s1 = Stack() for word in data.split(): print("pushing on s1:", word) s1.push(word) s2 = Stack() while not s1.isempty(): word = s1.pop() print("pushing " + word + " on stack s2") s2.push(word) $ python3 ovn1-01.py pushing on s1: pining pushing on s1: for pushing on s1: the pushing on s1: fjords pushing fjords on stack s2 pushing the on stack s2 pushing for on stack s2 pushing pining on stack s2 $ python2 ovn1-01.py ( pushing on s1:, pining ) ( pushing on s1:, for ) ( pushing on s1:, the ) ( pushing on s1:, fjords ) pushing fjords on stack s2 pushing the on stack s2 2

3 pushing for on stack s2 pushing pining on stack s2 2. Inläsning och utskrift #row = raw_input("ge en rad tal: ") row = input("ge en rad tal: ") ### python2 parted_row = row.split() for num in parted_row: print num # Ge en rad tal: # 5 // 10 // 15 // 20 // 25 // 42 $ python2 >>> row = raw_input("prompt> ") Prompt> a single line of text >>> expr = input("prompt> ") Prompt> $ python3 >>> row = input("prompt> ") Prompt> a single line of text >>> expr = eval(input("prompt> ")) Prompt> Läs från fil; sortera input = open("tred.txt") # See ex.4 for URL alist = [] for line in input: word = line.strip() alist.append(word) alist.sort() print(", ".join(alist)) # $ ln -s /afs/nada.kth.se/info/dd1320/www-csc/tilda12/ovn/tred.txt # $ python3 ovn1-03.py # Abies, Acer, Aesculus, Alnus, Betula, Carpinus, Corylus, Fagus, # Fraxinus, Juniperus, Larix, Malus, Picea, Populus, Populus, Prunus, # Quercus, Salix, Salix, Sambucus, Sorbus, Syringa, Taxus, Tilia, # Ulmus # # $ fmt tred_sv.txt ### egentligen radseparerad # Banan Apelsin Äpple Plommon Öl Körsbär Åkerbär # $ python3 ovn1-03.py ### med tred_sv.txt # Apelsin, Banan, Körsbär, Plommon, Äpple, Åkerbär, Öl lst = [ Ärlig, Caesar, Adam, Bertil, Östen, Åke ] lst.sort() print ", ".join(lst) # Adam, Bertil, Caesar, Ärlig, Åke, Östen # ^^^^^^^^^^ import locale locale.setlocale(locale.lc_all, sv_se.utf-8 ) ## alt. LC_COLLATE # returns sv_se.utf-8 lst = [ Ärlig, Caesar, Adam, Bertil, Östen, Åke ] # lst.sort(cmp=locale.strcoll) ## Old-style sorting (Python <= 2.4) lst.sort(key=locale.strxfrm) print ", ".join(lst) # Adam, Bertil, Caesar, Åke, Ärlig, Östen import locale 3

4 locale.setlocale(locale.lc_all, en_us.utf-8 ) lst = [ Ärlig, Caesar, Adam, Bertil, Östen, Åke ] lst.sort(key=locale.strxfrm) print ", ".join(lst) # Adam, Åke, Ärlig, Bertil, Caesar, Östen 4. Mäta tid; läsa URL # -*- coding: utf-8 -*- import urllib.request import time def fetchsortedfile(filnamn): """Read file with the given name, return words as sorted list.""" wfile = open(filnamn) alist = [] for line in wfile: word = line.strip() ### remove whitespace alist.append(word) alist.sort() return alist def lasurlsortera(url): """Fetch file from given URL, return words as sorted list.""" wwwfile = urllib.request.urlopen(url) alist = [] for line in wwwfile: word = line.strip() alist.append(word) alist.sort() return alist before = time.time() lst1 = fetchsortedfile("tred.txt") after = time.time() print("tid för filläsning:", after - before) before = time.time() lst2 = lasurlsortera(" "1320/tilda12/ovn/tred.txt") ### note linebreak after = time.time() print("tid för webbläsning:", after - before) # csc-datan$ python3 ovn1-04.py # Tid för filläsning: # Tid för webbläsning: # # csc-datan$ python3 ovn1-04.py # Tid för filläsning: # Tid för webbläsning: # # hemma-datan$ python ovn1-04.py # Tid för filläsning: e-05 # Tid för webbläsning: Abstrakt datastruktur för temperatur Observera att uppgiften går att lösa utan objektorientering: templib.py def CtoF(c): return c*5/ def FtoC(f): return (f - 32)*5/9 4

5 import templib c = 37.0 f = templib.ctof(c) print(c, " C =", f, " F =", templib.ftoc(f), " C") from templib import CtoF, FtoC c = 37.0 f = CtoF(c) print(c, " C =", f, " F =", FtoC(f), " C") # 37.0 C = F = C I detta fall skulle vi dock använda en abstrakt datatyp. temp.py """Temp - an abstract datatype for temperature Temp is used to represent temperature in multiple scales. """ zeroc = zerof = *5/9 # 0 C == K # 0 F == K # Conversion between Kelvin, degrees Celsius, degrees Fahrenheit # [ C] = [K] [K] = [ C] # [ C] = ([ F] - 32)*5/9 [ F] = [ C]*9/ # [K] = ([ F] )*5/9 [ F] = [K]*9/ class Temp: def init (self): self.k = 0 # Temperature in Kelvin def setk(self,k): self.k = K def setc(self,c): self.k = zeroc + C def setf(self,f): self.k = zerof + 5*F/9 def getk(self): return self.k def getc(self): return self.k - zeroc def getf(self): return (self.k - zerof)*9/5 from temp import Temp t = Temp() c = eval(input("vad är temperaturen i Celsius? ")) t.setc(c) print "Amerikaner kallar det", str(t.getf()) + " F" # Vad är temperaturen i Celsius? 100 # Amerikaner kallar det F Vi fick dock väldigt många decimaler för 37 C Representationsfel. Använd formaterad utskrift! 5

6 Representationsfel kan ge många decimaler: >>> I bas 2 (binärt) så kan värdet 0.1 inte representeras exakt. (Jfr. 1 3 decimalt.) = Fraction-klassen class Fraction: def init (self, top, bottom): self.num = top self.den = bottom def str (self): return str(self.num) + "/" + str(self.den) def show(self): print(self.num, "/", self.den, end=" ") def add (self,otherfraction): newnum = self.num*otherfraction.den + \ self.den*otherfraction.num newden = self.den * otherfraction.den return Fraction(newnum,newden) def lt (self,otherfraction): ## Cross-multiply by bd: a/b < c/d --> ad < bc num1 = self.num*otherfraction.den num2 = self.den*otherfraction.num return num1 < num2 def eq (self,otherfraction): ## See lt num1 = self.num*otherfraction.den num2 = self.den*otherfraction.num return num1 == num2 f = Fraction(6, 8) g = Fraction(10, 16) h = f + g f.show() # print "+", ### python2: trailing space supresses newline print("+", end=" ") g.show() print("=", end=" ") h.show() print() if f < g: print(str(f), "<", str(g)) else: print(str(f), ">=", str(g)) # 6 / / 16 = 176 / 128 # 6/8 < 10/16 Pythons klass Fraction (modulen fractions) har funktionen gcd för att beräkna största gemensamma nämnare (greatest common divisor, GCD). Det använder Euklides algoritm, som i Python kan skrivas: def gcd(a, b): while b: a, b = b, a%b return a 6

7 7. Teckenkodning Det är stor skillnad mellan Python2 och Python3. I Python2 finns datatyperna str, unicode, som bägge kan vara raw eller inte. I Python3 finns typerna text (klassen str) och (binär) data (bytes). Se text-vs-data-instead-of-unicode-vs-8-bit named_unicode = "\N{section sign}\n{digit four}\u \\" raw_string = r"\n{section sign}\n{digit four}\u \\" print(str(type(named_unicode)) + ": " + named_unicode) print(str(type(raw_string)) + ": " + raw_string) # <class str >: 42 42\ # <class str >: \N{section sign}\n{digit four}\u \\ ustr = "Å " print(ustr == "\u00c5 \u2022") # True #bstr = b"å " # SyntaxError: bytes can only contain ASCII literal characters. bstr = b"\xc3\x85 \xe2\x80\xa2" print("ustr:", str(type(ustr))) for c in ustr: print("unicode character", c, "code point", ord(c), "hex", hex(ord(c))) #ustr: <class str > # unicode character Å code point 197 hex 0xc5 # unicode character code point 32 hex 0x20 # unicode character code point 8226 hex 0x2022 print("bstr:", str(type(bstr))) for b in bstr: print("byte", b, "hex", hex(b)) # bstr: <class bytes > # byte 195 hex 0xc3 # byte 165 hex 0xa5 # byte 32 hex 0x20 # byte 226 hex 0xe2 # byte 128 hex 0x80 # byte 162 hex 0xa2 print(bstr.decode() == ustr) # True print(ustr.encode() == bstr) # True def iso2utf(strang): """ Konverterar från iso8859 till utf-8 """ ustrang = strang.decode( iso ) return ustrang.encode( utf-8 ) isostr = b R\xe4ksm\xf6rg\xe5s ; #isostr.decode() # UnicodeDecodeError: utf8 codec can t decode bytes in # position 1-3: invalid data #iso2utf(isostr) # b R\xc3\xa4ksm\xc3\xb6rg\xc3\xa5s utfstr = iso2utf(isostr).decode(); print(isostr, "->", utfstr) 7

8 8. (extra) Kopiera referenser a = [1, 7, 10, 13] ac = a[:] ac[2] = -1; print "-" * 40 print "a = ", a print "ac = ", ac # # a = [1, 7, 10, 13] # ac = [1, 7, -1, 13] class Person: def init (self, name): self. name = name def change_name(self, newn): self. name = newn def repr (self): return "<" + self. class. name + ":" + self. name + ">" a = [ Person("Alice"), Person("Bob"), Person("Charlie") ] ac = a[:] ac[1] = Person("Duncan") ac[2].change_name("eric") print "-" * 40 print "a = ", a print "ac = ", ac # # a = [<Person:Alice>, <Person:Bob>, <Person:Eric>] # ac = [<Person:Alice>, <Person:Duncan>, <Person:Eric>] 8