Hey there,

Please help. Not sure what's wrong with the code. It'll be great if you could help.

Thank You.

# Oops, try again. get_class_average([alice]) returned 83.8666666667 instead of 91.15 as expected

**shikher26**#1

@shikher26,

Could please edit your Post and provide the code in ASCII instead of an image ??!

What i do see on the fly...

In your *get_class_average function which has 1 parameter _students*

and this

*students*

**parameter**is used as a

**variable**throughout the function.

As you call the *get_class_average* function**get_class_average()**

you will have to provide a so-called **argument**

in our case a *list*

like**get_class_average([lloyd,tyler,alice])**

BUT

in your function you then *re-assign* =students= **variable**.

*some quotes from the outer-world*:

**argument is the value/variable/reference being passed in,

parameter is the receiving variable used within the function/block**

OR

**"parameters" are called "formal parameters",

while "arguments" are called "actual parameters".**

**shikher26**#3

Hey, thanks for replying

The new code works! Thanks!

lloyd = {

"name": "Lloyd",

"homework": [90.0, 97.0, 75.0, 92.0],

"quizzes": [88.0, 40.0, 94.0],

"tests": [75.0, 90.0]

}

alice = {

"name": "Alice",

"homework": [100.0, 92.0, 98.0, 100.0],

"quizzes": [82.0, 83.0, 91.0],

"tests": [89.0, 97.0]

}

tyler = {

"name": "Tyler",

"homework": [0.0, 87.0, 75.0, 22.0],

"quizzes": [0.0, 75.0, 78.0],

"tests": [100.0, 100.0]

}

def average(numbers): #Function

total = sum(numbers)

total = float(total)

avg = total/len(numbers)

return avg

print average(lloyd["homework"])

def get_average(student):

homework = average(student["homework"])

quizzes = average(student["quizzes"])

tests = average(student["tests"])

```
return 0.1 * homework + 0.3 * quizzes + \
0.6 * tests
```

def get_letter_grade(score):

if score >= 90:

return "A"

elif score >= 80:

return "B"

elif score >= 70:

return "C"

elif score >= 60:

return "D"

else:

return "F"

print get_letter_grade(average(tyler["homework"]))

def get_class_average(students):

results = []

students = [alice, lloyd, tyler]

for key in students:

x = get_average(key)

results.append(x)

return average(results)

print get_class_average([lloyd, tyler, alice])

**khs01**#4

Im having the same trouble, can somebody help me?!

```
lloyd = {
"name": "Lloyd",
"homework": [90.0, 97.0, 75.0, 92.0],
"quizzes": [88.0, 40.0, 94.0],
"tests": [75.0, 90.0]
}
alice = {
"name": "Alice",
"homework": [100.0, 92.0, 98.0, 100.0],
"quizzes": [82.0, 83.0, 91.0],
"tests": [89.0, 97.0]
}
tyler = {
"name": "Tyler",
"homework": [0.0, 87.0, 75.0, 22.0],
"quizzes": [0.0, 75.0, 78.0],
"tests": [100.0, 100.0]
}
# Add your function below!
def average(numbers) :
total = float(sum(numbers))
return total / len(numbers)
def get_average(student) :
homework = average(student["homework"])
quizzes = average(student["quizzes"])
tests = average(student["tests"])
return 0.1 * homework + 0.3 * quizzes + 0.6 * tests
def get_letter_grade(score) :
if score >= 90 :
return "A"
elif score >= 80 :
return "B"
elif score >= 70 :
return "C"
elif score >= 60 :
return "D"
else :
return "F"
def get_class_average(students) :
students = [lloyd, alice, tyler]
results = []
for student in students :
results.append(get_average(student))
return average(results)
```

@khs01,

What happens if i *call* your function

`get_class_average()`

with the

**argument**

*[alice,tyler]*

like

`get_class_average([alice,tyler])`

*( you =re-assign= students ??? )*

@khs01

=remember= you are *re-assigning* the **parameter** *students*

meaning that it does not matter what **argument** you give

as you *call* the *get_class_average()* function

the =local= **variable** *students* will get the Value *[alice,tyler]*

### the FUNCTION talk

```
def myFunc( param1, param2):
# Begin of =myFunc= FUNCTION-BODY
# this =myFunc= function- has 2 PARAMETERS param1 and param2
# param1 and param2 PARAMETERS are used
# as -local- VARIABLES throughout the =myFunc= FUNCTION-BODY
print( param1 + " and " + param2 )
#End of =myFunc= FUNCTION-BODY
```

If you want to call/execute the *myFunc function*

you will have to add a pair of parentheses to *myFunc*

like**myFunc()**

As the *myFunc function* was defined

as having 2

**parameters**

you have to

*provide*2

**arguments**

in our case 2

*string VALUES*"Alena" and "Lauren"

like

**myFunc("Alena","Lauren")**

*some quotes from the outer-world*:

**argument is the value/variable/reference being passed in,

parameter is the receiving variable used within the function/block**

OR

**"parameters" are called "formal parameters",

while "arguments" are called "actual parameters".**

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

++++ function with 1 parameter using return-statement

```
def myFunction( param1 ):
# //Begin of =myFunction= FUNCTION-BODY
# //=myFunction= function has 1 PARAMETER param1
# //this param1 PARAMETER is used as a -local- VARIABLE
# //throughout the =myFunction= FUNCTION-BODY
return param1;
# //End of FUNCTION-BODY
```

You have defined a *myFunction* **function**

which takes 1 **parameter** *param1*

this *param1* **parameter** is used

as a **variable** throughout the =myFunction= FUNCTION-BODY.

If you want to call/execute this *myFunction* **function**

and this *myFunction* **function** was defined

as having 1 **parameter** *param1*

you will have to *provide* 1 **argument**

in our case a "*number* VALUE" **4****myFunction( 4 )**

*some quotes from the outer-world*:

**argument is the value/variable/reference being passed in,

parameter is the receiving variable used within the function/block**

OR

**"parameters" are called "formal parameters",

while "arguments" are called "actual parameters".**

#### ============================================

As you are using the **return**-*statement* in your *myFunction* **function**

you will only get a **return-value** no-display.

You can however *capture* this **return-value** in a **variable**

and then use the *print*-**method** to do a display.

```
theResult = myFunction( 4 )
print theResult
```

OR *directly*

`print myFunction( 4 )`