Joseph Quigley said unto the world upon 2005-04-11 20:23:Well, now I've learned what def is good for. But what could I put in the parenthesis of def foo():?
Of course self is always available, but what would maybe def foo(number1): do? An error right? So I now repeat my self, what else besides self could I put in there?
Thanks, Joseph
Hi Joseph,
as Liam explained, you put the arguments (if any) to the function in
the parenthesis.
But, I want to address the bit where you said "Of course self is
always available". *Any* valid Python identifier (or name) can be used
("is always available"):
def silly(a_name_I_picked_at_random): # well, not quite... print a_name_I_picked_at_random # at random ;-) ...42silly(42)
The name a_name_I_picked_at_random is like a "placeholder" inside the
function for whatever input we gave to the function. And *that* can be
any object:
<function silly at 0x01298070>silly(silly)
Some functions require certain sorts of inputs in virtue of what they
try to do with them, but we can still pass any sort of object in. For
instance, Liam had:
... return a + bdef foo(a, b):
...
Now, try this:
foo(42, '42')Traceback (most recent call last): File "<interactive input>", line 1, in ? File "<interactive input>", line 2, in foo TypeError: unsupported operand type(s) for +: 'int' and 'str'
That's not a problem with Liam's function; it's a problem that I
caused by sending it inappropriate inputs.
At any rate, you are correct that you can always name an argument
"self". But "self" is, by *very* strong convention, used only within
classes. Simplifying[*] a bit, a method is a function defined
internal to a class. If you define a method in a class, you call the
first argument of the method definition "self", and it is
automatically interpreted as a reference to the `active' instance of
the class on which the method is called.
So, don't use "self" outside of method definitions. You can ("we are
all adults here"), but doing so will only confuse things given the
strength of the convention.
[*] The simplification comes in that not all methods in a class need
to be bound to an instance, so not all methods employ "self". But, my
guess is that is something you shouldn't be worrying about just yet.
Best,
Brian vdB
_______________________________________________ Tutor maillist - [email protected] http://mail.python.org/mailman/listinfo/tutor
Brian is correct.
Also I would like to point out that def foo(*args): #this allows for any number of arguments to be passed.
The *args is powerful when used correctly. *args is a list of any length of arguments being passed to the function and/or class, and the arguments passed can be any type/object you want to pass .
So you might do something like.
def foo(*args):
print len(args)
# this prints the length of the list of the arguements passed
# so using that function you would see something like. in the example I only used basic types but you can pass objects as well.
6foo(1, 2, 3, "cat", "mouse", ['bee', 'honey', 'stinger'])
Notice that the length that is returned is only 6 but there are 8 items so it appears to have been passed to the function. In actuallity it is only 6 items. There is 3 integers, then 2 strings, then 1 list that is 3 items long. Thus the length of the list args is 6 items long. I wouldn't recomend passing mixed types like this to a function using args because it can get very confusing. I hope this helps you out and doesn't confuse you. I know from first hand experience the first time I saw the *args in some code I was lost.
If you know the type of variables that are to be passed to the function and the number of them then it is easier to specify them, and use names. such as.
def bar(num1, num2): #this is not catching invalid data types and such.
return num1 + num2 #returns the sum of num1 + num2
3bar(1, 2)
Also if you want to have default values passed incase the call is issued without any arguments passed.
#This will take 2 arguments and add them together and return the sum
# but the default values will fill in the remaining (missing) arguments.
def my_foo(num1 = 0.0, num2 = 1.0):
return num1 + num2
1.0my_foo()
7.7my_foo(6.7)
4my_foo(2, 2)
The reason that my_foo() returns 1.0 is that no arguments were given so the default values were used and the 2nd argument default value is 1.0 and was added to the 1st argument's default value of 0.0. Thus 0.0 + 1.0
The reason that in the my_foo(6.7) example 7.7 is returned is that the default value of the 2nd argument is used since no 2nd argument was given was given. so it was 6.7 + 1.0
And Finally both arguments were specified my_foo(2, 2) the function takes both values and adds them giving you 4.
I hope this helps, and does not make any more confusing. I try to be consise when giving information however I like to be thorough in my explanations.
Jeff _______________________________________________ Tutor maillist - [email protected] http://mail.python.org/mailman/listinfo/tutor
