Ahhhhh. Now this is where things start getting really interesting. Writing
various functions properly is what almost all coding concerns itself with. The
main body of the code is generally pretty short, with just a few function calls
that, due to the wonderful nature of functions, do whatever you want. First
you should remember how you might use functions to do what you want. Currently, however, your
instructional vocabulary is limited to the functions that Python has built in.
Should you want to do more complex things (and everyone's first coding project
is always enormously complex) you'lll want to make your own ones to accomplish
But, enough beating about the bush, it's time to see how this might be
useful, and then learn how you can use this technique to further your own ends.
The general idea about a function is that it is a machine that takes in data,
does something to it, and spits the data back out. This is quite similar to
the functions you may have learned about in your math classes, and they should
feel similar because this way of thinking about things was thought up by
math geeks. The way that this is expressed in computer
science land is that you have a function that takes
arguments and returns a value. So, what is a
function you might want to make? Well, perhaps you are making a string checker
program. If so, then you might want to check whether or not a particular
string conforms to a particular format. If the test for conformity was a
complicated one, and you knew about functions, yopu could give your buddy the
job of writing the "does it conform" function - a function that would accept a
string and return either true or false - and you could write the easier
Functions are useful in many ways:
- they make your code clearer by decomposing funcionality into easily recognizable subparts.
- they make collaboration possible by allowing you to just use the other code without having to know how all of its internal bits work
- the idea of a function that calls itself (a concept known as recursion) can be used to create expressive and easy tor read code very succinctly.1
As such, you really should make every effort to decompose repeated
functionality into functions. A good rule of thumb is that if the same lines
of code ever happen three times over the course of your program, then those
three lines should be turned into a function. Things like this, however, are
the beginnings of a dive into talking about software engineering
, and this is
just a how to code
So, how do you work these crazy things? Well, we'll do that string-conformance-testing idea. We'll check whether or not a particular string is made up of two words, where the first word starts with 'a', and the second word starts with 'b':
words = string.split(words)
if len(words) != 2:
return words == 'a' and words == 'b'
Whoah. There is a lot of new stuff there, so if you look at that and go "what
the hell is he smoking?", that is quite understandable. Let's just take it
line by line: (line numbers added for ease of reference)
1: def conformsToSpec(words):
2: import string
4: words = string.split(words)
6: if len(words) != 2:
7: return 0
9: return words == 'a' and words == 'b'
def means "define", as in "define conformsToSpec to be a function that takes one argument and calls that argument 'words'". So this line, while unfamiliar, should not be too highly voodoo. This is the function definition or, for the more computer science inclined, the function's signature. This line tells you what the function is called and how many arguments to give it.
- take in the
- take the passed in string and use the function
string.split() to turn it into an array of all of the words in the string. Store the resulting array in the variable
- check the length of the word. This should feel familiar.
- (remember, this line is only executed if the condition in the if clause is true) return the value 0, which evaluates to false when used in an if statement.
- Here's what is probably the most confusing line. This line evaluates the statement just like an if clause, and then returns the truth value of the statement.
Talking about this too much might make it even more confusing, so let's just
try using this in a piece of code to see how it might turn out. We'll assume
that this function is defined somewhere in your file already.
strings = [ "a bouncer", "Apple bat", "apple", "a b c d", "ab", "booger alpha" ]
for str in strings:
print str, "is an okay string!"
print str, "does not conform"
What do you think this code will do? Try it and find out! Because computer
scientisits like to generalize
, functions can of course call other functions,
and can contain while()s and for()s and if()s and really almost anything that
it makes sense to do.
Functions are ean enourmously general concept, but the general form for declaring one is, as shown above:
This format is an almost complete description, but it is important to note that the return statement is optional and other returns may be placed in the middle of the function as shown previously. This means that some functions (such as
) don't return a value. This is okay. The english sentence that this compares to is a little bit long and tortured, but it might go a little something like this:
I would like you to create a function called FUNCTIONNAME that takes ARGUMENTS and, given those arguments, performs INSTRUCTIONS and then returns SOMETHING.
So, if you wanted to, you could make a function called
that took in as its one argument
, preformed the instructions
celsius = (fahrenheight-32)*5/9
and then returned
. Written out in python, it is much more succinct:
This brevity, coupled with the lack of ambiguity, is the main reason that
programming languages don't use the nore "natural" english language method of
writing things down. Also, for more complicated functions and conditions, the
sentences have the ability to descend into meaninglessness due to their length. Initially this trick of decoding into english is useful, but you will find that over time the code way of expressing it becomes more natural in most cases.
Now that you know how to write your own functions, you're unstoppable. The Linux kernel, Microsoft Word, Mozilla, e2, and all the other programs you use on a daily basis are just programs like you now know how to make. They may use other languages, and they may use weird things like objects, but in essence, all that these programs are are sequences of instructions with
defs. So go wild. Believe it or not, you know know everything you need to know to understand almost any program. Writing one yourself is where the apprenticeship aspect of coding comes in.
In the following chapters, the things I present are more of a denouement of the things that have led up to this point. They will help you when and if your project goes beyond 100 or so lines, but until that point you're unstoppable. Have fun, and revel in your newfound powers
Continue on to find out how to divide your program up into multiple files,
and for some rantings and ravings about good style and good languages. Also,
you might find something interesting to read.
<< | Learn to Program | >>
- This is mostly a geek thing that makes no sense right now and seems silly, but I promise that it is totally useful and will allow you to write your programs more succinctly with fewer bugs. Let recursion do the work for you and To iterate is human, to recurse, divine