ይህ ትምህርት ገና ወደ አማርኛ አልተተረጎመም፤ ስለዚህ በእንግሊዝኛ ቀርቧል። የእንግሊዝኛውን ገጽ ክፈቱ

Scope

4 min read

In lesson 5.1 you saw that each call gets its own frame of names, gone when the call ends. That one idea explains a whole family of surprises: names that vanish, a total that isn't the total you meant, and lists that change from inside a function. By the end you'll predict all of them.

Names made in a call stay in the call

Predict what this prints. Look at the last line of the output when you reveal it.

ውጤቱን ገምቱ

Decide before you look. Guessing wrong is how this sticks.

def add_up(prices):
    total = sum(prices)
    return total

add_up([120, 80])
print(total)

Your prediction

Python prints

Traceback (most recent call last):
  File "<your code>", line 6, in <module>
    print(total)
          ^^^^^
NameError: name 'total' is not defined

total was made inside the call, so it belonged to that call's frame. When the call ended, the frame and total went with it. The returned value, 200, was never given a name either.

A name made inside a function is locallocalMade inside a function call, belonging to that call's frame only. It disappears when the call ends.: it lives in that call's frame and nowhere else. Names made outside every function are globalglobalMade outside every function, at the top level of the program. Any function can read them.. Where a name can be used is its scopescopeThe part of a program where a name can be used. A local name's scope is its own call.. To use the result outside, return it and give it a name: bill = add_up([120, 80]).

A local name can even share its spelling with a global one. They're still two names:

Two names called total

Press Next to run one line at a time. Each arrow shows the object a name refers to. Each call gets its own frame of names, below the frame that called it.Each row is one step: the line that just ran, and the object each name refers to after it, frame by frame, oldest first.

1total = 0
2 
3def add_up(prices):
4    total = sum(prices)
5    return total
6 
7bill = add_up([120, 80])

Step 1 of 6

Every step: the line that ran, and the object each name refers to after it
Step	Line	Names and objects
1	1	global total → V1 0
2	3	global total → V1 0
3	7	global total → V1 0 add_up(prices) prices → L2 [120, 80]
4	4	global total → V1 0 add_up(prices) prices → L2 [120, 80] total → V3 200
5	5	global total → V1 0 add_up(prices) prices → L2 [120, 80] total → V3 200 add_up(prices) returns 200 to global.
6	7	global total → V1 0 bill → V3 200 L2 [120, 80] (no name refers to it now)

Line 4 made a new total in the call's frame. The global total is still 0 at the end.

Reading a global, and assigning one

A function can read a global name. Python looks in the call's frame first, and if the name isn't there, in the global names:

rate = 0.15

def vat(price):
    return price * (1 + rate)

print(vat(1000))

Ctrl or Cmd + Enter runs

Assigning is different. Predict what happens here:

ውጤቱን ገምቱ

Decide before you look. Guessing wrong is how this sticks.

count = 0

def add_visit():
    count = count + 1

add_visit()
print(count)

Your prediction

Python prints

Traceback (most recent call last):
  File "<your code>", line 6, in <module>
    add_visit()
    ~~~~~~~~~^^
  File "<your code>", line 4, in add_visit
    count = count + 1
            ^^^^^
UnboundLocalError: cannot access local variable 'count' where it is not associated with a value

Because count is assigned inside the function, Python treats it as local for the whole function. So count + 1 reads the local count, which has no value yet.

Any assignment to a name inside a function makes that name local to the function, from its first line. The error says exactly that: a local variable with no value yet. Python has a way to say "I mean the global one", the global statement:

count = 0

def add_visit():
    global count
    count = count + 1

add_visit()
print(count)

Ctrl or Cmd + Enter runs

It works, but avoid it. When any function can change a global, you have to read every function to know what a name is, and a function is hard to reuse or test. The clean pattern is pass values in, return values out:

def add_visit(count):
    return count + 1

visits = 0
visits = add_visit(visits)
print(visits)

Ctrl or Cmd + Enter runs

Lists as parameters

A parameter is a new name for the caller's object, the rule from lesson 4.8. Predict both programs before you look.

ውጤቱን ገምቱ

Decide before you look. Guessing wrong is how this sticks.

def change(lst):
    lst.append(9)

a = [1]
change(a)
print(a)

Python prints

[1, 9]

lst and a refer to the same list. append changes that list, so a sees the 9.

ውጤቱን ገምቱ

Decide before you look. Guessing wrong is how this sticks.

def rebind(lst):
    lst = [0]

a = [1]
rebind(a)
print(a)

Python prints

[1]

lst = [0] makes a new list and moves the local name lst to it. The caller's list, and a, are untouched.

Step through both. In change, two names in two frames refer to one list:

change(a): one list, two names

1def change(lst):
2    lst.append(9)
3 
4a = [1]
5change(a)

Step 1 of 5

Every step: the line that ran, and the object each name refers to after it
Step	Line	Names and objects
1	1	global
2	4	global a → L1 [1]
3	5	global a → L1 [1] change(lst) lst → L1 [1]
4	2	global a → L1 [1, 9] change(lst) lst → L1 [1, 9] change(lst) returns None to global.
5	5	global a → L1 [1, 9]

In rebind, only the local name moves:

rebind(a): the local name moves

1def rebind(lst):
2    lst = [0]
3 
4a = [1]
5rebind(a)

Step 1 of 5

Every step: the line that ran, and the object each name refers to after it
Step	Line	Names and objects
1	1	global
2	4	global a → L1 [1]
3	5	global a → L1 [1] rebind(lst) lst → L1 [1]
4	2	global a → L1 [1] rebind(lst) lst → L2 [0] rebind(lst) returns None to global.
5	5	global a → L1 [1] L2 [0] (no name refers to it now)

Changing the object shows through every name; moving a name doesn't. If a function should give back a new list, return it.

ጥያቄ

def reset(scores): scores = []. After data = [5, 7] and reset(data), what is data?

Where Python looks

When you use a name, Python searches four scopes in order, called LEGB, and uses the first match:

Scope	Its names
Local	Names made in the current call
Enclosing	Names in a function around this one (functions inside functions, later)
Global	Names made at the top level of the program
Built-in	Python's own names: `print`, `len`, `sum`

መልመጃ

No more global

This works, but add_price changes a global. Rewrite it so add_price(total, price) takes the current total and returns the new one, with no global. It already prints 200; it should still print 200 when you're done.

Your code

total = 0

def add_price(price):
    global total
    total = total + price

add_price(120)
add_price(80)
print(total)

Ctrl or Cmd + Enter runs

መፍትሄውን አሳይ

This is one way to solve it, not the only one. If yours prints the same thing, it works.

def add_price(total, price):
    return total + price

total = 0
total = add_price(total, 120)
total = add_price(total, 80)
print(total)

ዋና ዋና ነጥቦች

Names made inside a call are local: they live in that call's frame and disappear when it ends.
A local name and a global name with the same spelling are two different names.
Reading a global works; assigning a name anywhere in a function makes it local, hence UnboundLocalError.
Avoid global: pass values in, return values out.
A parameter shares the caller's object: changing it shows outside; moving the name doesn't.