Reminders. Lecture Outline. Lecture Agenda. Namespaces II. Namespaces I. COMP10001 Foundations of Computing PEP8, Modules and Files

Transcription

1 COMP10001 Foundations of Computing PEP8, Modules and Files Reminders Semester 1, 2017 Tim Baldwin & Egemen Tanin Grok Worksheets 8 11 due at the end of this week Have a go at the early-release tutesheet (see the Lectures/Workshops page on the LMS) prior to your workshop this week Project 1 due at the end of Friday of next week version: 1102, date: March 29, The University of Melbourne Lecture Agenda Last lecture: More detail on functions and mutability This lecture: Functions and namespaces PEP8 Modules File access Namespaces I A namespace is a mapping (dictionary!) from names to objects (eg variables and functions). When Python starts up there is the global namespace When a function is called, a local namespace for that function is called, and then forgotten when the function ends Scope is the area of Python code where a particular namespace is used 1 a = 3 2 def f(x): 3 i = 2 4 return x+i 5 b = 6 In this code snippet Namespaces II The global namespace contains a, f and b When f is called, its local namespace has x and i When Python tries to find an object, it first looks in the local namespace, and then in the global namespace

2 1 i = 3 2 def f(x): 3 i = 1 4 return x+i 5 print (f (10)) Namespaces III In this case, the Line 4 code uses the i in its local namespace (Line 3) Scope of x is Lines 2,3,4. Scope of global i is Lines 1, 2 and 5. Scope of the i in f is Lines 3 and 4. Namespaces IV Now for the tricky part: functions within functions 1 i = 3 2 def f(x): 3 i = def g(x): 6 i = 1 7 return x+i return g( x+i) 11 print (f (10)) 12 print (g (10)) f s namespace contains g and others Namespaces V Make life easy 1 def f(x): 2 i = def g(x): 5 return ( x+i) 6 7 return (g(x+i)) 8 9 print (f (10)) Python searches local namespace, and then enclosing function namespaces, and then global namespace. You can list the current namespace with dir(). Don t use the same parameter names in sub-functions Avoid global variables wherever possible (always!) Capitalize constants (a common convention) def f(x): ADDER_F = 2 def g(y): ADDER_G = 1 return ( y + ADDER_G ) return (g(x + ADDER_F )) Going Pythonic As you are perhaps picking up on gradually, Python is big on stylistics and readability, and the idea that there is one right way of doing things In this vein, Python has stylistic guidelines on right and wrong ways of writing code (= PEP8), some of which we take on board in this subject, and start automatically checking for in your code from Worksheet 10 (and for all the projects)

3 Going Pythonic: White Space Indentation should always be in multiples of 4 spaces (which Grok does by default; so long as you don t modify this/code outside Grok, you should be fine): There should be a single space between operators and their operands, and after commas: w_len =0 for i in ('a','b'): w_len = w_len +1 w_len = 0 for i in ('a', 'b'): w_len = w_len + 1 Going Pythonic: Segmentation Going Pythonic: Avoid Long Lines Lines must not exceed 79 characters def fun ( thing ): ''' take `thing ` and do nothing to it, but document it in a long - winded way ''' if 0 > 1 and " totoro " in " avengers " and " abracadabra ". isalpha (): pass return thing def fun ( thing ): ''' take `thing ` and do nothing to it, but document it in a long - winded way ''' if 0 > 1 and " totoro " in " avengers " and \ " abracadabra ". isalpha (): pass return thing Going Pythonic: Don t Stack Use blank lines to separate logical sections: def w_count ( word ): w_len = 0 for char in word : w_len += 1 return w_len def w_count ( word ): # letter count w_len = 0 # count the letters for char in word : w_len += 1 return w_len Avoid multiple statements on the same line Always start a new line after if, elif, else, while, for, etc. a = True ; b = 0 if a: b += 1 else : b += 2 a = True b = 0 if a: b += 1 else : b += 2 Going Pythonic: Comment Sensibly Going Pythonic: Name Sensibly Make sure your comments do not contradict your code Do not state the obvious in comments # initialise `a` to 0 a = 0 # increment `a` a -= 1 # count of letters a = 0 a -= 1 Never use the characters l, O or I as single-character variable names Use self-descriptive variable names l = I = 1 O = 0 count = min_val = 1 max_val = 0

4 Going Pythonic: Function Names Going Pythonic: Constant Names Function names should be lowercase, with words separated by underscores as necessary to improve readability def DOSOMETHING (x):... def do_something (x):... Constants should be written in all capital letters with underscores separating words, and listed in the header of your code k = 3 def fun (i, k=k): CHAR_SIZE = 3 def fun (i, k= CHAR_SIZE ): Going Pythonic: Comparing Booleans Don t compare Boolean values to True or False using == if val == False : elif val == True : if val2 == True : return True else : return False if not val : else : return val2 Modules I Modules are pre-prepared stores of convenient methods/variables which expand the functionality of Python To access the contents of a module, import it import math area = math. pi * radius **2 phi = (1 + math. sqrt (5))/2 import adds the module to the local namespace Modules II 1 def area ( radius ): 2 import math 3 return math. pi * radius **2 4 5 print ( area (2)) 6 print (pi) What is in the local namespace of area? What is in the global namespace? Does line 6 work?

5 Modules III It is also possible (but generally avoided) to import all methods and constants from a library into the local namespace: from math import * area = pi * radius **2 Alternatively you can selectively import objects: from math import pi, e area = pi * radius **2 including the possibility of renaming them: from math import pi as mypi area = mypi * radius **2 Files Reading Files Computer memory is volatile RAM, cache, registers Power off, it is all gone Python program finishes, it is all gone Computers use disk for longer term storage A physical hard disk that mechanically spins Flash drives without mechanical parts The cloud (sends it off to a physical disk) Disks have filesystems (except on systems such as ios, where data is linked to an app) Python can read and write files Reading data in from a (local) file: FILENAME = ' jabberwocky. txt ' text = open ( FILENAME ). read () lines = open ( FILENAME ). readlines () fp = open ( FILENAME ) for line in fp:... read() reads the entire file readlines() reads into a list of lines for iterates over lines in the file File Writing/Appending File Generators Writing to a file: FILENAME = 'file. txt ' text = open ( FILENAME,'w') text. write ('Tim woz ere ') text. close () Appending to a file: FILENAME = 'file. txt ' text = open ( FILENAME,'a') text. write ('Tim woz ere again ') text. close () Even better, you can use a generator : with open ('file. txt ') as f: for line in f: print ( line ) with the advantage that: it automatically closes the file it is more efficient than direct iteration

6 Lecture Summary What is PEP8, and what are stylistic conventions to look out for in Python? What are modules? How do you read a file? What is defaultdict and why is it useful? What are list comprehensions and why are they useful? What do += and *= mean?