python for newbies.htm

1000 HOWTOs for various needs [WINDOWS]

Finally, an example: <PRE>&gt;&gt;&gt; f.readlines() #Our imaginary file; create it if you want
['This is the first line\012', 'This is the second line\012', "Hmm I'm running out
of creative things to say\012", 'Alright, this is the last line']
&gt;&gt;&gt; f.seek(0) #You need this to go back to the beginning of the file; see below
&gt;&gt;&gt; f.readline()
'This is the first line\012'
</PRE>Just in case you're wondering, the \012 at the end of every line is just a 
newline. When reading files, Python replaces simple \ characters like \n with 
their hex (ASCII) code. If you didn't get that, just remember that \012's are 
really \n's. There are three (maybe four) more important methods of files. 
First, read and seek. read just reads the entire file into a string, or a 
maximum number of bytes if you specify it. seek needs one argument, which is the 
offset in the file to go to, or seek. Huh? Well, Python reads files by putting a 
little pointer in one and moving it along. When you read from a file, the little 
pointer moves along to the end of the part you read. If you read again, it'll 
start from where the pointer left off. seek will tell the pointer to go back (or 
forward) to a specified point in the file. Here's another example, using the 
same imaginary file as above: <PRE>&gt;&gt;&gt; f.seek(12) #Offsets start at 0, therefore 12 is 'f'
&gt;&gt;&gt; f.read(10)
'first line'
&gt;&gt;&gt; f.seek(0)
&gt;&gt;&gt; f.read() #Whole file. You probably shouldn't do this with big files.
"This is the first line\012This is the second line\012Hmm I'm running out
of creative things to say\012Alright, this is the last line"
</PRE>Then, finally, there is the write function, which (surprise!) writes to 
your file. Just put in the parentheses the string you want to write. Be sure you 
have a file opened in mode w, r+, or a, though! Also, if you want to create a 
new file you must use the mode w or a, not r+. The last method is close, which 
closes the file and frees up any memory it's been using. It's always good 
programming practice to close any files when you're done with them or before you 
leave. One last example for this section, then we move on: <PRE>&gt;&gt;&gt; f = open( "mynewfile.txt", "w" )
&gt;&gt;&gt; f.write( "This is some text" )
&gt;&gt;&gt; f.close()
&gt;&gt;&gt; f.read() #Oops! Can't read a closed file (or a write-only file for that matter)
Traceback (most recent call last):
  File "&lt;stdin&gt;", line 1, in ?
ValueError: I/O operation on closed file
&gt;&gt;&gt; f = open( "mynewfile.txt" )
&gt;&gt;&gt; f.read()
'This is some text'
</PRE>
<P></P>
<P><FONT size=-2><A 
href="#top">Back 
to top</A></FONT></P>
<HR>

<H2 align=center><A name=mod>Modules</A></H2>
<H3 align=center><A name=mod1>Overview and Importing</A></H3>
<P>Before we talk about Python's wide variety of builtin modules, let's go over 
what a module is first and how to get to them. A module is a script (or compiled 
library) that can be loaded into the interpreter environment separately from the 
core language of Python. Modules are accessed with the import statement, which 
can be used in a number of ways: <PRE>&gt;&gt;&gt; import sys #For these examples we're using the builtin sys module
&gt;&gt;&gt; sys.argv #Access names from the modules like you would an object
['']
&gt;&gt;&gt; from sys import argv #Another way to call it
&gt;&gt;&gt; argv
['']
&gt;&gt;&gt; from sys import * #Get everything in the sys module
&gt;&gt;&gt; stdout
&lt;open file '&lt;stdout&gt;', mode 'w' at 0x80d34b0&gt;
</PRE>Confusing? Not really. Let's go through it. The first line imports the 
module sys (one of the <A 
href="#builtin">builtin 
modules</A>). Notice on the next line that we needed to call a member of sys, 
argv (the arguments passed to the interpreter), with a . like we did for 
objects. This is using the so-called sys namespace, i.e. all sys members are 
accessed using, obviously, the name 'sys'. Alternatively, if we put 'from 
&lt;module&gt; import &lt;members&gt;', we use the global namespace. Then you 
can access the method's members just like any other sort of local variables or 
base functions. If you want to use the whole module in the global namespace, 
just do a 'from &lt;module&gt; import *'. Not too hard, eh? 
<P></P>
<P><FONT size=-2><A 
href="#top">Back 
to top</A></FONT></P>
<HR>

<H3 align=center><A name=builtin>Builtin Modules</A></H3>
<P>Python, being the versatile language it is, has a large selection of modules 
built into the default distribution. And I do mean large: at my count, there are 
196 modules available in Python 2.0 (including obsolete and OS-specific ones). 
When I say "builtin," this doesn't mean you don't have to import them, just that 
they should be included in Python installation. So, I'll list a choice 5 or so 
here, with basic descriptions of what they do and only a few of their members. 
</P>
<UL>
  <LI><B><FONT size=+1>sys</FONT></B> - Basic system/program functions 
  <UL>
    <LI><B>argv</B> - List of commands passed to the interpreter 
    <LI><B>stdout, stdin, stderr</B> - Basic standard output, standard input, 
    and standard error. These can be accessed like normal files. 
    <LI><B>exit</B> - Exits the program gracefully, accepting a value as the 
    exit code (basically 0=good exit, non-0=error) 
    <LI><B>path</B> - The paths Python looks in to find modules to import 
  </LI></UL>
  <LI><B><FONT size=+1>math</FONT></B> - Mathematical functions and constants. I 
  won't list them all here, but math contains many functions like sin, acos, 
  tanh, log, etc. Here are the constants: 
  <UL>
    <LI><B>pi</B> - The mathematical constant &#960;. The ratio of a circle's 
    diameter to its circumference, approximately 3.1415926535897931 
    <LI><B>e</B> - The base of the natural logarithm (ln). Get it with the sum 
    of 1/k! for all numbers k 0-&gt;infinity. Oddly enough, factorials (and 
    infinity) are not in the math module. </LI></UL>
  <LI><B><FONT size=+1>string</FONT></B> - Functions for more manipulations of 
  strings 
  <UL>
    <LI><B>printable</B> - A string of all so-called printable characters. Also 
    available are digits, letters (uppercase and lowercase), whitespace, and 
    punctuation. 
    <LI><B>atoi, atof, atol</B> - Convert strings to int, float, and long, 
    respectively. In Python 2.0 you should use builtins functions int, float, 
    and long. 
    <LI><B>find</B> - Find the lowest index where the second string (argument) 
    appears in the first. 
    <LI><B>count</B> - Count the number of times the second string appears in 
    the first. 
    <LI><B>split</B> - Split the string given in the first argument by 
    whitespace characters; return a list. If a second argument is given, the 
    string is split according to that instead of whitespace. 
    <LI><B>strip</B> - Strip leading and trailing whitespace from the given 
    string. 
    <LI><B>replace</B> - Replace all occurrences of the second string in the 
    first string with the third string. Err, look at it this way: replace( str, 
    "old", "new" ) replaces all occurrences of "old" in str with "new". </LI></UL>
  <LI><B><FONT size=+1>random</FONT></B> 
  <UL>
    <LI><B>seed</B> - Seeds the random number generator with three optional 
    arguments; defaults to the current time 
    <LI><B>random</B> - Returns the next random number as a floating-point 
    number between 0 and 1. 
    <LI><B>randint</B> - Returns a random number between two given integers. 
    <LI><B>uniform</B> - Same as randint, only with floating-point numbers. 
    <LI><B>choice</B> - Randomly chooses an element from the specified list or 
    tuple. </LI></UL>
  <LI><B><FONT size=+1>time</FONT></B> - Functions for getting and manipulating 
  local and arbitrary times. See the Python library documentation for more 
  complete information. 
  <UL>
    <LI><B>time</B> - No arguments, returns a long number that's your system's 
    current time, in seconds since...some time. Not really useful without some 
    sort of parser, except for seeding randoms. 
    <LI><B>localtime</B> - A parser. Given a time (like that returned by the 
    time function), it returns a tuple with the following information: year 
    (four-digit), month (1-12), day (1-31), hour (0-23), minute (0-59), second 
    (0-61 - 60 &amp; 61 for leap seconds, never used), weekday (0-6, Monday is 
    0), day (1-366), daylight savings time (0 - no, 1 - yes, -1 - system 
    default). Useful :) 
    <LI><B>gmtime</B> - Same as above, except in Greenwich Mean Time, not your 
    system's local time. 
    <LI><B>asctime</B> - Given a tuple from localtime or gmtime, returns a 
    string in the format 'Thu Mar 22 18:24:35 2001'. </LI></UL>
  <LI><B><FONT size=+1>re</FONT></B> - Regular expression (regexp) operators. I 
  won't cover them here, but I thought all you Perl fans out there might like to 
  know they exist in Python. There are some definite peculiarities about regexps 
  in Python, so read the docs...docs are your friends :). </LI></UL>
<P><FONT size=-2><A 
href="#top">Back 
to top</A></FONT></P>
<HR>

<H3 align=center><A name=yours>User-Defined Modules and Functions</A></H3>
<P>Of course, what use are all these modules if you can't use your own? Well, a 
user-defined module is just a .py file in one of Python's module directories. To 
import the module, it's run, and any functions, variables, classes, etc. are 
imported in. You can specify what to import, just like for any other module. 
Well, then, that's all well and good, but a big part of these modules is 
functions. How to make your own functions, then? Ok. </P>
<P>Alright. So we want a function. Since I like math, we'll do a simple 
logarithm to any base using the log function in the math module. Here we go, try 
this: <PRE>&gt;&gt;&gt; def logb( b, n ):
...   from math import log
...   a = log(n)/log(b)
...   if a - int(a) == 0: #a is an int
...     return int(a)
...   else:
...     return a
...
</PRE>How nice. Only a couple things should need explaining, unless you haven't 
taken high school algebra (hey no offense...I'm just a freshman :). This 'def' 
thing? Well, it's just the name of the function and the arguments it takes. I 
should hope you have a good idea of what arguments are now. Then there's return. 
It's...uh...what the function returns :). Execution stops after a return 
statemnt, just like a break statement. Except it returns something. Ok. Well, 
I've kinda run out of things to say...so here's an example module, just for 
practice. Hey, this is a tutorial, isn't it? Let's go, put this in moremath.py: <PRE>#!/usr/bin/python

def logb( b, n ): #Definition
  from math import log #Need this!
  a = log(n)/log(b) #Change of base formula
  if a - int(a) == 0: #a is an int
    return int(a) #Get rid of that decimal :)
  else: #a is a float
    return a #Just return it

#Ye Olde Golden Ratio &lt;www.verbose.net&gt;
phi = 1.6180339887498948
</PRE>And now in the interpreter: <PRE>&gt;&gt;&gt; import moremath
&gt;&gt;&gt; moremath.phi #Floating point numbers aren't that accurate, you may notice
1.6180339887499999
&gt;&gt;&gt; from moremath import logb
&gt;&gt;&gt; logb(2,1024)
10
</PRE>Wow! A module! Just like other modules! But you did it myself! Or I did it 
yourself...or...wait...you did it yourself. If you look in the directory where 
you put moremath.py now, you'll now find a moremath.pyc file. This is a 
'compiled' file, which is not really compiled (it's bytecode - kinda like a Java 
.class file), but has less memory overhead than a .py file. As far as I know 
.pyc files are not portable, though, so if you're just using this module for 
yourself you can use the .pyc but if you want to distribute it, I recommend you 
keep the .py file. In any case, it's certainly easier to edit your source if you 
still have a .py file. Any questions :)? 
<P></P>
<P><FONT size=-2><A 
href="#top">Back 
to top</A></FONT></P>
<HR>

<H2 align=center><A name=close>In Closing</A></H2>
<H3 align=center><A name=perl>Why Python is Better than Perl</A></H3>
<P>I admit it: maybe Python isn't better than Perl. It's different, to say the 
least. For many things it <I>is</I> better. And it's got definite advantages, 
and that's what I thought I'd just review, or look at, or list, or whatever. 
Here goes. </P>
<UL>
  <LI>Intuitiveness. Instead of all that nasty, obfuscated code, Python has 
  syntax and blocking that resembles, somewhat, normal (English) speech and 
  indenting. 
  <LI>High-levelness. List slicing, tuple packing, etc. allow for high-level 
  manipulation of data without all that mucking about with 
  pointers...wait...that's C...and efficient though it may be, it sometimes even 
  confuses the 黚erhacker in me. But it's still easier in Python than Perl. 
  <LI>More integrated object-oriented (OO) support. OO in Perl involves working 
  with hashes as classes and weird stuff like that. Bottom line, Python was 
  designed from the start to be OO...even though I didn't talk about classes too 
  much. Sorry. 
  <LI>Better C integration. Well, this is opinionated here, but I think 
  embedding Python in C is easier than Perl...what can I say? 
  <LI>Interactive mode. No need to put scripts in separate files. You know what 
  I'm saying. 
  <LI>Wider variety of data structures. Perl has arrays, hashes, and scalars. 
  Python has scalars (int, float, long), lists, dictionaries (which I didn't 
  talk about; they're like hashes or associative arrays), tuples. And it's 
  extensible and evolving, according to the docs. 
  <LI>range function. People complain about the lack of a generic for loop, like 
  Perl has. range really makes the for loop...without having a whole different 
  type of loop. Less overhead. And you can use range for other things, too. 
  <LI>Monty Python. 'Nuff said. </LI></UL>
<P><FONT size=-2><A 
href="#top">Back 
to top</A></FONT></P>
<HR>

<H3 align=center><A name=ref>References</A></H3>
<UL>
  <LI><A href="http://www.python.org/">Python.org</A>. A must-see. 
  <LI><A href="http://www.python.org/doc/current/">Current Python docs</A>. 
  Gotta read them. 
  <LI><A href="http://www.zope.org/">Zope</A>. Great webserver written in 
  Python. 
  <LI><A href="http://www.programmershaven.com/zone23/links/link281.htm">Python 
  section at ProgrammersHaven</A>. More good links. 
  <LI><A href="http://blacksun.box.sk/">Black Sun Research Facility</A>. Great 
  site for networking, programming, cracking, OSes, etc. This tutorial should be 
  published there :) 
  <LI><A href="http://www.pythonline.com/">Pythonline</A>. Monty Python, may or 
  may not be the official site, I'm not sure. </LI></UL>
<P>Any comments, questions, glowing praise, rants, hatemail, feel free to <A 
href="mailto:[e-mail]">mail me</A> or leave a message for me at <A 
href="http://dvd.box.sk/wb/?did=blacksun">BSRF's message board</A>. I'm a 
member, I check it regularly. Hatemail is ok, but death threats are discouraged. 
</P>
<P>Well, we've come to the end, at long last. I hope you've learned something, 
and you aren't too high on the adrenaline rush of coding. I'm not good at these 
ending things, so I think I'll just trail off right...about...now... </P>
<P><FONT size=-2><A 
href="#top">Back 
to top</A></FONT></P></FONT></BODY></HTML>