University of Texas at Arlington, TX, USA

Transcription

1 Dept. of Computer Science and Engineering University of Texas at Arlington, TX, USA

2 The set of program statements over which a variable exists (i.e. can be referred to) It is about understanding, for any variable, what its associated is. The problem is that mul;ple namespaces might be involved.

3 For Python, there are poten&ally mul&ple namespaces that could be used to determine the object associated with a variable. Remember, namespace is an associa&on of name and objects We will begin by looking at func;ons.

4 Each func;on maintains a namespace for names defined locally within the func&on. Locally means one of two things: a name assigned within the func;on an argument received by invoca;on of the func;on

5 For each argument in the func;on invoca;on, the argument s associated object is passed to the corresponding parameter in the func;on.

6

7 The diagram should make it clear that the parameter name is local to the func&on namespace. Passing means that the argument and the parameter, named in two different namespaces, share an associa;on with the same object. So passing means sharing in Python.

8 If a parameter is assigned to a new, then just like any other assignment, a new associa;on is created. This assignment does not affect the object associated with the argument, as a new associa;on was made with the parameter.

9

10 When passing a mutable data structure, it is possible that if the shared object is directly modified, both the parameter and the argument will reflect that change. Note that the opera;on must be a mutable change, a change of the object. An assignment is not such a change.

11

12

13 Func;ons return one thing, but it can be a chunky thing. For example, they can return tuples. Thus, mul;ple things can be returned by being packed into a tuple or other data structure.

14 >>> def foo(): a = 2 b = 3 return a,b >>> T = foo() >>> print T # (2, 3) >>> print foo() # (2, 3) >>> x,y = foo() >>> print x # 2 >>> print y # 3

15 >>> def foo(a): a[1]='x' return a >>> foo(2) # Error >>> foo('abc') # Error >>> foo([1,2,3]) [1, 'x', 3] >>> foo((1,2,3)) # Error

16 If you assign a in a func;on, that name becomes part of the local namespace of the func;on. It can have some odd effects.

17 def myfun (param): param.append(4) return param mylist = [1,2,3] newlist = myfun(mylist) print mylist,newlist

18 Main space mylist Param=myList foo space param

19 Main space mylist Param=myList foo space param

20 def myfun (param): param=[1,2,3]; # erase any parenthood! param.append(4) return param mylist = [1,2,3] newlist = myfun(mylist) print mylist,newlist

21 Main space mylist Param=myList foo space param

22 Main space mylist Param=myList foo space param 1 2 3

23 Main space mylist Param=myList foo space param

24 def myfun (param): param=param.append(4) return param mylist = [1,2,3] newlist = myfun(mylist) print mylist,newlist

25 Main space mylist Param=myList foo space param

26 Main space mylist Param=myList foo space param

27 Main space mylist Param=myList foo space param None