1. Getting Started with Python: Constructs and Pitfalls Sean Deitz Advanced Programming Seminar September 13, 2013

2. Source for this talk Guidelines taken from –Mark Summerfield's Programming in Python 3 A Complete Introduction to the Python Language In particular, the opening –Python's “Beautiful Heart” in 8 pieces I agree with most of them, but I'll be adding my comments.

3. 1. Data Types Dynamic typing Simple casting (str() int()) Lists and Dictionaries (later) type(var) [] for sequence access Raw strings and unicode strings

4. 2. Object References Everything is object references –Much like Java Basic data types included a = 6, a = “hello”, both are fine Strong typing on objects, references not Automatic printing at shell (later)

5. 3. Collection Data Types Tuples (,) –Immutable ordered sets Lists [] –Mutable ordered sets Dictionary {} –Hash table of (key, index) pairs

6. 4. Logical Operators is and is not None = > –Chaining -1<=x<=1 –Python 3 type errors over addresses True and False booleans “and” and “or” in for collections

7. 5. Control Flow Statements if cond: block –elif and else Indentation for blocks –Tabs and spaces different –4 space standard while cond: block: –break, continue, else

8. 5. Control Flow Continued for var in iterable: block –for (ind, var) in enumerate(iterable) iterables –Lists, Sequences (range(start,end,step)) –Dictionaries (keys, values, items, ordered) try: block except Type as var: –Mutliple execpts, tuples –Else, finally

9. 6. Arithmetic Operators Usual operators –+ - / * += -= /= *= // ** –Notably no ++ or -– operators –Unary + and – exist, so ++x is valid syntax ints are immutable –Actually changes reference to new object Overloaded for strings and lists (seq) –TypeError for mismatched types (str + int)

10. 7. Input/Output input([prompt string]) file = open(filename, mode) –modes are read, write, or append (r, w, a) –Returns a file object –Default path python install location file.write(str) file.close() at the end print, pprint and others

11. 8. Functions def funName(parameters): block –Remember tabbing is important –Return type dynamic as with all variables Strongly recommended to use builtins –import module name –from module import function (*) –dir(modulename), help(function name) Modules for classes

12. Other useful notes subprocess.call([program, parameters]) –May need to adjust path –Windows may need to call cmd os.chdir(path) –os.path.realpath(os.curdir) –sys.path[1] sys.argv

13. Other useful notes cont'd Sequence slicing [start:end:step] –All parameters optional, [start,end) List comprehensions –[function for var(s) in sequence] –Similar to a lambda, quick construction Lambda functions –lambda parameters: function –Useful for map, filter, reduce...

14. Other caveats IDLE is limited –Becomes unresponsive over large buffers Many things are already implemented –Look for existing libraries to do what you want –dir and help are your best friends in the interpreter Incorporating built in properties takes some time to get used to __prop__

15. Other caveats continued Incorporating built in properties takes some time to get used to (__prop__) Document strings as first line of function Be careful with copy constructors from copy import deepcopy class functions take self as first param

16. Lists Heterogenous collections, indexed from 0 Append, extend, and slicing for insertion –+ does extend, adds sequential elements –list[x:x] = seq inserts values at that location –list[x:x+1] = [] removes value at index x len(list) gives you the length list.sort() modifies, sorted(list) does not

17. Lists list.reverse() modifies, reversed(list) does not (also returns an iterator, not a list) append and pop to modify list end insert(val, 0), list = list[1:] for beginning index, remove, and count take values –remember to use in for contains queries Lists can be self-referential, lazily evaluated (list.append(list))

18. Strings Use the same slicing techniques as lists –Except insertion, immutable objects –s = s[:x] + 'new' + s[x+3:] ' “ equivalent, escape less ''' or “”” for multiline strings Find, replace, count –Defined for fixed substrings (re next) str.split([del]) returns a list split on del

19. Regular Expressions import re –Regular expression library, standard form re.compile(string) - optional –Generates the regular expression pattern re.search(pattern, string) -matches re.sub(pattern, repl, string) - new string re.findall(pattern, string) – just strings re.finditer(pattern, string) - matches

20. More tricks if __name__ == '__main__': –Main function only called when executed Arguments –foo(val=default, *args, **kwargs) pass for an empty block # for inline comments, ''' for multiline pdb debugger, traceback for exceptions

21. Questions? Topics you'd like to hear more about Sample code/structures in action Coding conventions