Positional, keyword and default arguments

Transcription

1 O More on Python n

2 O Functions n

3 Positional, keyword and default arguments in repl: >>> def func(fst, snd, default="best!"):... print(fst, snd, default)... >>> func(snd='is', fst='python') ('Python', 'is', 'best!')

4 Variable argument list in repl: >>> def func(fst, *args):... for arg in args: print(fst, arg)... >>> func("i love ", "apples", "Mozart", 42) ('I love ', 'apples') ('I love ', 'Mozart') ('I love ', 42)

5 Dictionaries as arguments in repl: >>> def func(fst, **args):... for key,value in args.items():... print(fst, key, " and ", value)... >>> func("i love ", apples="pears", life = 42) ('I love ', 'life', ' and ', 42) ('I love ', 'apples', ' and ', 'pears')

6 Unpacking arguments in repl: >>> def f(a,b):... print(a + " and " + b)... >>> f(*["a","b"]) a and b

7 Functions are objects in repl: >>> def func(arg):... print(arg)... >>> func <function func at 0x100492d70> >>> var = func >>> var("hello") Hello

8 Functions are objects... so we can pass them as arguments to other functions in repl: >>> def is_even(i):... return ((i % 2) == 0)... >>> m = map(is_even, range(6)) >>> m [True, False, True, False, True, False]

9 lambdas A lambda is an anonymous function Code executed as a nameless function Expressions only (no statements) If something more complex is needed, use defs def is a statement followed by a list of statements (it's possible to nest them) in repl: >>> s = map(lambda x: x * x, [2, 4]) >>> s [4, 16]

10 List Comprehensions The Proposed Solution It is proposed to allow conditional construction of list literals using for and if clauses. They would nest in the same way for loops and if statements nest now. Rationale List comprehensions provide a more concise way to create lists in situations where map() and filter() and/or nested loops would currently be used.

11 List Comprehensions Syntax: [x,y for...] is disallowed [(x,y) for...] instead [... for x... for y] y varies faster in repl: >>> xlist = [1,2,3] >>> ylist = [1,2,3] >>> [x + y for x in xlist for y in ylist] [2, 3, 4, 3, 4, 5, 4, 5, 6]

12 List Comprehensions >>> m = map(lambda n: n % 2 == 0, range(6)) >>> m [True, False, True, False, True, False] >>> [n % 2 == 0 for n in range(6)] [True, False, True, False, True, False] >>> f = filter(lambda n: n % 2 == 0, range(6)) >>> f [0, 2, 4] >>> [n for n in range(6) if x % 2 == 0] [0, 2, 4]

13 Set comprehensions >>> {x % 2 == 0 for x in range(6)} set([false, True]) >>> s = {"this", "is", "a", "set"} >>> s.add("this") >>> s set(['a', 'this', 'is', 'set'])

14 Magic methods Generally invoked by Python when using certain syntax >>> obj = object() >>> dir(obj) [' class ', ' delattr ', ' doc ', ' format ', ' getattribute ', ' hash ', ' init ', ' new ', ' reduce ', ' reduce_ex ', ' repr ', ' setattr ', ' sizeof ', ' str ', ' subclasshook ']

15 Magic methods class n(object): def init (self, i): print "init" self.i = i def add (self, o): print "add" return self.i + o def int (self): print "int" return self.i def str (self): print "str" return str(self.i) >>> obj = n(10) init >>> obj + 10 add 20 >>> int(obj) int 10 >>> str(obj) str '10' >>> int(obj) int 10

16 Magic methods, again >>> def m(): >>> def n(): >>> pass >>> return n >>> f = m() >>> f <function main.n> >>> dir(f) [' call ', ' class ', ' closure ', ' code ', ' defaults ', ' delattr ', ' dict ', ' doc ', ' format ', ' get ', ' getattribute ', ' globals ', ' hash ', ' init ', ' module ', ' name ', ' new ', ' reduce ', ' reduce_ex ', ' repr ', ' setattr ', ' sizeof ', ' str ', ' subclasshook ', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']

17 Example: call in repl: >>> square = lambda x: x * x >>> square(10) 100 >>> square. call (10) 100 >>> def square(x):... return x * x... >>> square(10) 100 >>> square. call (10) 100 >>> class Squarer(object):... def call (self, x):... return x * x... >>> square = Squarer() >>> square(10) 100 >>> square. call (10) 100

18 O Exceptions n

19 in repl: >>> def print_list(lst, index):... element = lst[index]... print(element)... >>> lst = range(5) >>> print_list(lst, 1) 1 >>> print_list(lst, 9) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 2, in print_list IndexError: list index out of range

20 in repl: >>> def print_list(lst, index):... try:... element = lst[index]... except IndexError as e:... print(e)... else:... print(element)... >>> lst = range(5) >>> print_list(lst, 1) 1 >>> print_list(lst, 9) list index out of range

21 in repl: >>> try:... f = open("non-existing-file", "r")... except IOError:... print("must... pass... on...")... raise... finally:... print("finally!")... if file is not None:... file.close()... Must... pass... on... Finally! Traceback (most recent call last): File "<stdin>", line 2, in <module> IOError: [Errno 2] No such file or directory: 'non-existing-file'

22 O Namespaces n

23 Namespaces A namespace is a set of mappings between a name and an object In Python this is currently implemented as dictionaries where the key is the variable name and the value is the value the variable refers to Therefore, a namespace can be accessed as a dictionary

24 Namespaces When we ask for the value of a variable, Python will search for it in 1. local namespace(s) -- innermost nesting level first 2. global namespace 3. built-in namespace If the name can not be found, Python will raise a NameError

25 Namespaces builtins : holds built-in functions, types and exceptions global NS for each module: holds classes, functions, variables and other imported modules local NS for each function: holds function arguments and any locally defined variables

26 Namespaces Assignment to a variable introduces the name to the local namespace To make the variable global, the global keyword can be used

27 Making the local global in repl: >>> x = 10 >>> def l_change_x():... x=2... >>> l_change_x() >>> print x 10 in repl: >>> x = 10 >>> def g_change_x():... global x... x = >>> g_change_x() >>> print x 20

28 O Classes Again n

29 Visibility Python assumes programmers are grown up, responsible people Everything is public If you wish to indicate that an attribute is used for implementation purposes and should NOT be messed with: name the attribute with a leading underscore -- _x

30 Classes - background Prior to Python 2.2, user defined types were inherently different from built-in types (e.g. list, int...) You could not inherit from built-in types Python 2.2 was the first step towards typeclass unification

31 Classes - background User defined types pre 2.2 are generally referred to as old-style classes In Python 2.2 new-style classes were introduced Old-style classes and new-style classes coexist in Python , but they are removed in Python 3.0+

32 Classes - background A classic class is a class that is defined with a class statement that has no new style classes amongst its base classes, i.e. inherits from no other class, or only from classic classes, applying the definition recursively A new-style class has the built-in object class as one of its base classes

33 Classes in Python 2.2+ (These definitions are equivalent in Python 3.0+) Old-style classes class SomeClass: <statement-1>.. <statement-n> in repl: >>> class A:... pass... >>> dir(a) [' doc ', ' module '] New-style classes class SomeClass(object): <statement-1>.. <statement-n> >>> class A(object):... pass... >>> dir(a) [' class ', ' delattr ', ' dict ', ' doc ', ' format ', ' getattribute ', ' hash ', ' init ', ' module ', ' new ', ' reduce ', ' reduce_ex ', ' repr ', ' setattr ', ' sizeof ', ' str ', ' subclasshook ', ' weakref ']

34 Defining classes When entering a class definition, Python will introduce a new namespace for that class Attributes and function definitions will bind to this new namespace in repl: >>> class A(object):... a = >>> A.a 10

35 Defining classes in repl: >>> class A(object):... def init (self, name):... self.name = name... def hi(self):... print self.name, " says hi!"... >>> A <class ' main.a'> When a class definition is left (at the end of the block) a new class object will be created This new object will be bound to the current scope (name space)

36 in repl: Defining classes >>> A <class ' main.a'> >>> A. init <unbound method A. init > >>> a = A("test") >>> a. init <bound method A. init of < main.a object at 0x1005a6150>> >>> a.hi() test says hi! >>> A.hi(a) # equivalent with previous line test says hi! The first argument in function definitions will be reserved for the instance object which the method will operate on This argument is typically named self, but it is legal to name it this or whatever

37 Class objects Basically, you can only do two things with a class object: Reference attributes -- SomeClass.x Create instances -- a = A( Python )

38 But...

39 As we saw before: Method objects A. dict [' str '] <function str at 0x10049d0c8> >>> a = A(4) >>> a. str <bound method A. str of < main.a object at 0x >>

40 O The End n

41 References Programming Python by Mark Lutz Descriptor.htm