--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sttp/basic_python/intro.rst~ Tue Mar 02 18:43:02 2010 +0530
@@ -0,0 +1,719 @@
+============
+Basic Python
+============
+
+This document is intended to be handed out at the end of the workshop. It has
+been designed for Engineering students who are Python beginners and have basic
+programming skills. The focus is on basic numerics and plotting using Python.
+
+The system requirements:
+ * Python - version 2.5.x or newer.
+ * IPython
+ * Text editor - scite, vim, emacs or whatever you are comfortable with.
+
+Introduction
+============
+
+The Python programming language was created by a dutch named Guido van Rossum.
+The idea of Python was conceived in December 1989. The name Python has nothing
+to do with the reptilian, but its been named after the 70s comedy series
+"Monty Python's Flying Circus", since it happens to be Guido's favourite
+TV series.
+
+It is a test.
+This is a test
+
+Current stable version of Python is 2.6.x, although Python 3.0 is also the stable
+version, it is not backwards compatible with the previous versions and is hence
+not entirely popular at the moment. This material will focus on the 2.6.x series.
+
+Python is licensed under the Python Software Foundation License (PSF License)
+which is GPL compatible Free Software license (excepting license version 1.6 and 2.0)
+It is a no strings attached license, which means the source code is free to modify
+and redistribute.
+
+The Python docs define Python as "Python is an interpreted, object-oriented,
+high-level programming language with dynamic semantics." A more detailed summary
+can be found at http://www.python.org/doc/essays/blurb.html. Python is a language that
+has been designed to help the programmer concentrate on solving the problem at hand
+and not worry about the programming language idiosyncrasies.
+
+Python is a highly cross platform compatible language on account of it being an
+interpreted language. It is highly scalable and hence has been adapted to run on
+the Nokia 60 series phones. Python has been designed to be readable and easy to use
+
+**Resources available for reference**
+
+* Web: http://www.python.org
+* Doc: http://www.python.org/doc
+* Free Tutorials:
+ * Official Python Tutorial: http://docs.python.org/tut/tut.html
+ * Byte of Python: http://www.byteofpython.info/
+ * Dive into Python: http://diveintopython.org/
+
+**Advantages of Python - Why Python??**
+
+* Python has been designed for readability and ease of use. Its been designed in
+ such a fashion that it imposes readability on the programmer. Python does away
+ with the braces and the semicolons and instead implements code blocks based on
+ indentation, thus enhancing readability.
+
+* Python is a high level, interpreted, modular and object oriented language.
+ Python performs memory management on its own, thus the programmer need not bother
+ about allocating and deallocating memory to variables. Python provides extensibility
+ by providing modules which can be easily imported similar to headers in C and
+ packages in Java. Python is object oriented and hence provides all the object oriented
+ characteristics such as inheritance, encapsulation and polymorphism.
+
+* Python offers a highly powerful interactive programming interface in the form
+ of the 'Interactive Interpreter' which will be discussed in more detail in the
+ following sections.
+
+* Python provides a rich standard library and an extensive set of modules. The
+ power of Python modules can be seen in this slightly exaggerated cartoon
+ http://xkcd.com/353/
+
+* Python interfaces well with most other programming languages such as C, C++
+ and FORTRAN.
+
+Although, Python has one setback. Python is not fast as some of the compiled
+languages like C or C++. Yet, the amount of flexibility and power more than make
+up for this setback.
+
+
+The Python Interpreter
+======================
+
+The Interactive Interpreter
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Typing *python* at the shell prompt on any standard Unix/Gnu-Linux system and
+hitting the enter key fires up the Python 'Interactive Interpreter'. The Python
+interpreter is one of the most integral features of Python. The prompt obtained
+when the interactive interpreter is similar to what is shown below. The exact
+appearance might differ based on the version of Python being used. The ``>>>``
+thing shown is the python prompt. When something is typed at the prompt and the
+enter key is hit, the python interpreter interprets the command entered and
+performs the appropriate action. All the examples presented in this document are
+to be tried hands on, on the interactive interpreter.
+
+::
+
+ Python 2.5.2 (r252:60911, Oct 5 2008, 19:24:49)
+ [GCC 4.3.2] on linux2
+ Type "help", "copyright", "credits" or "license" for more information.
+ >>>
+
+Lets try with an example, type ``print 'Hello, World!'`` at the prompt and hit
+the enter key.
+
+::
+
+ >>> print 'Hello, World!'
+ Hello, World!
+
+This example was quite straight forward, and thus we have written our first
+line of Python code. Now let us try typing something arbitrary at the prompt.
+For example:
+
+::
+
+ >>> arbit word
+ File "<stdin>", line 1
+ arbit word
+ ^
+ SyntaxError: invalid syntax
+ >>>
+
+The interpreter gave an error message saying that 'arbit word' was invalid
+syntax which is valid. The interpreter is an amazing tool when learning to
+program in Python. The interpreter provides a help function that provides the
+necessary documentation regarding all Python syntax, constructs, modules and
+objects. Typing *help()* at the prompt gives the following output:
+
+::
+
+ >>> help()
+
+ Welcome to Python 2.5! This is the online help utility.
+
+ If this is your first time using Python, you should definitely check out
+ the tutorial on the Internet at http://www.python.org/doc/tut/.
+
+ Enter the name of any module, keyword, or topic to get help on writing
+ Python programs and using Python modules. To quit this help utility and
+ return to the interpreter, just type "quit".
+
+ To get a list of available modules, keywords, or topics, type "modules",
+ "keywords", or "topics". Each module also comes with a one-line summary
+ of what it does; to list the modules whose summaries contain a given word
+ such as "spam", type "modules spam".
+
+ help>
+
+
+As mentioned in the output, entering the name of any module, keyword or topic
+will provide the documentation and help regarding the same through the online
+help utility. Pressing *Ctrl+d* exits the help prompt and returns to the
+python prompt.
+
+Let us now try a few examples at the python interpreter.
+
+Eg 1:
+::
+
+ >>> print 'Hello, python!'
+ Hello, python!
+ >>>
+
+Eg 2:
+::
+
+ >>> print 4321*567890
+ 2453852690
+ >>>
+
+Eg 3:
+::
+
+ >>> 4321*567890
+ 2453852690L
+ >>>
+
+::
+
+ Note: Notice the 'L' at the end of the output. The 'L' signifies that the
+ output of the operation is of type *long*. It was absent in the previous
+ example because we used the print statement. This is because *print* formats
+ the output before displaying.
+
+Eg 4:
+::
+
+ >>> big = 12345678901234567890 ** 3
+ >>> print big
+ 1881676372353657772490265749424677022198701224860897069000
+ >>>
+
+::
+
+ This example is to show that unlike in C or C++ there is no limit on the
+ value of an integer.
+
+Try this on the interactive interpreter:
+``import this``
+
+*Hint: The output gives an idea of Power of Python*
+
+*ipython* - An enhanced interactive Python interpreter
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The power and the importance of the interactive interpreter was the highlight
+of the previous section. This section provides insight into the enhanced
+interpreter with more advanced set of features called **ipython**. Entering
+*ipython* at the shell prompt fires up the interactive interpreter.
+
+::
+
+ $ ipython
+ Python 2.5.2 (r252:60911, Oct 5 2008, 19:24:49)
+ Type "copyright", "credits" or "license" for more information.
+
+ IPython 0.8.4 -- An enhanced Interactive Python.
+ ? -> Introduction and overview of IPython's features.
+ %quickref -> Quick reference.
+ help -> Python's own help system.
+ object? -> Details about 'object'. ?object also works, ?? prints more.
+
+ In [1]:
+
+This is the output obtained upon firing ipython. The exact appearance may
+change based on the Python version installed. The following are some of the
+various features provided by **ipython**:
+
+ Suggestions - ipython provides suggestions of the possible methods and
+ operations available for the given python object.
+
+Eg 5:
+
+::
+
+ In [4]: a = 6
+
+ In [5]: a.
+ a.__abs__ a.__divmod__ a.__index__ a.__neg__ a.__rand__ a.__rmod__ a.__rxor__
+ a.__add__ a.__doc__ a.__init__ a.__new__ a.__rdiv__ a.__rmul__ a.__setattr__
+ a.__and__ a.__float__ a.__int__ a.__nonzero__ a.__rdivmod__ a.__ror__ a.__str__
+ a.__class__ a.__floordiv__ a.__invert__ a.__oct__ a.__reduce__ a.__rpow__ a.__sub__
+ a.__cmp__ a.__getattribute__ a.__long__ a.__or__ a.__reduce_ex__ a.__rrshift__ a.__truediv__
+ a.__coerce__ a.__getnewargs__ a.__lshift__ a.__pos__ a.__repr__ a.__rshift__ a.__xor__
+ a.__delattr__ a.__hash__ a.__mod__ a.__pow__ a.__rfloordiv__ a.__rsub__
+ a.__div__ a.__hex__ a.__mul__ a.__radd__ a.__rlshift__ a.__rtruediv__
+
+In this example, we initialized 'a' (a variable - a concept that will be
+discussed in the subsequent sections.) to 6. In the next line when the *tab* key
+is pressed after typing '*a.*' ipython displays the set of all possible methods
+that are applicable on the object 'a' (an integer in this context). Ipython
+provides many such datatype specific features which will be presented in the
+further sections as and when the datatypes are introduced.
+
+Editing and running a python file
+=================================
+
+The previous sections focused on the use of the interpreter to run python code.
+While the interpeter is an excellent tool to test simple solutions and
+experiment with small code snippets, its main disadvantage is that everything
+written in the interpreter is lost once its quit. Most of the times a program is
+used by people other than the author. So the programs have to be available in
+some form suitable for distribution, and hence they are written in files. This
+section will focus on editing and running python files. Start by opening a text
+editor ( it is recommended you choose one from the list at the top of this page ).
+In the editor type down python code and save the file with an extension **.py**
+(python files have an extension of .py). Once done with the editing, save the
+file and exit the editor.
+
+Let us look at a simple example of calculating the gcd of 2 numbers using Python:
+
+**Creating the first python script(file)**
+::
+
+ $ emacs gcd.py
+ def gcd(x,y):
+ if x % y == 0:
+ return y
+ return gcd(y, x%y)
+
+ print gcd(72, 92)
+
+To run the script, open the shell prompt, navigate to the directory that
+contains the python file and run ``python <filename.py>`` at the prompt ( in this
+case filename is gcd.py )
+
+**Running the python script**
+::
+
+ $ python gcd.py
+ 4
+ $
+
+Another method to run a python script would be to include the line
+
+``#! /usr/bin/python``
+
+at the beginning of the python file and then make the file executable by
+
+$ chmod a+x *filename.py*
+
+Once this is done, the script can be run as a standalone program as follows:
+
+$ ./*filename.py*
+
+Basic Datatypes and operators in Python
+=======================================
+
+Python provides the following set of basic datatypes.
+
+ * Numbers: int, float, long, complex
+ * Strings
+ * Boolean
+
+Numbers
+~~~~~~~
+
+Numbers were introduced in the examples presented in the interactive interpreter
+section. Numbers include types as mentioned earlier viz., int (integers), float
+(floating point numbers), long (large integers), complex (complex numbers with
+real and imaginary parts). Python is not a strongly typed language, which means
+the type of a variable need not mentioned during its initialization. Let us look
+at a few examples.
+
+Eg 6:
+::
+
+ >>> a = 1 #here a is an integer variable
+
+Eg 7:
+::
+
+ >>> lng = 122333444455555666666777777788888888999999999 #here lng is a variable of type long
+ >>> lng
+ 122333444455555666666777777788888888999999999L #notice the trailing 'L'
+ >>> print lng
+ 122333444455555666666777777788888888999999999 #notice the absence of the trailing 'L'
+ >>> lng+1
+ 122333444455555666666777777788888889000000000L
+
+
+Long numbers are the same as integers in almost all aspects. They can be used in
+operations just like integers and along with integers without any distinction.
+The only distinction comes during type checking (which is not a healthy practice).
+Long numbers are tucked with a trailing 'L' just to signify that they are long.
+Notice that in the example just lng at the prompt displays the value of the variable
+with the 'L' whereas ``print lng`` displays without the 'L'. This is because print
+formats the output before printing. Also in the example, notice that adding an
+integer to a long does not give any errors and the result is as expected. So for
+all practical purposes longs can be treated as ints.
+
+Eg 8:
+::
+
+ >>> fl = 3.14159 #fl is a float variable
+ >>> e = 1.234e-4 #e is also a float variable, specified in the exponential form
+ >>> a = 1
+ >>> b = 2
+ >>> a/b #integer division
+ 0
+ >>> a/fl #floating point division
+ 0.31831015504887655
+ >>> e/fl
+ 3.9279473133031364e-05
+
+
+Floating point numbers, simply called floats are real numbers with a decimal point.
+The example above shows the initialization of a float variable. Shown also in this
+example is the difference between integer division and floating point division.
+'a' and 'b' here are integer variables and hence the division gives 0 as the quotient.
+When either of the operands is a float, the operation is a floating point division,
+and the result is also a float as illustrated.
+
+Eg 9:
+::
+
+ >>> cplx = 3 + 4j #cplx is a complex variable
+ >>> cplx
+ (3+4j)
+ >>> print cplx.real #prints the real part of the complex number
+ 3.0
+ >>> print cplx.imag #prints the imaginary part of the complex number
+ 4.0
+ >>> print cplx*fl #multiplies the real and imag parts of the complex number with the multiplier
+ (9.42477+12.56636j)
+ >>> abs(cplx) #returns the absolute value of the complex number
+ 5.0
+
+Python provides a datatype for complex numbers. Complex numbers are initialized
+as shown in the example above. The *real* and *imag* operators return the real and
+imaginary parts of the complex number as shown. The *abs()* returns the absolute
+value of the complex number.
+
+Variables
+~~~~~~~~~
+
+Variables are just names that represent a value. Variables have already been
+introduced in the various examples from the previous sections. Certain rules about
+using variables:
+
+ * Variables have to be initialized or assigned a value before being used.
+ * Variable names can consist of letters, digits and underscores(_).
+ * Variable names cannot begin with digits, but can contain digits in them.
+
+In reference to the previous section examples, 'a', 'b', 'lng', 'fl', 'e' and 'cplx'
+are all variables of various datatypes.
+
+::
+
+ Note: Python is not a strongly typed language and hence an integer variable can at a
+ later stage be used as a float variable as well.
+
+Strings
+~~~~~~~
+
+Strings are one of the essential data structures of any programming language.
+The ``print "Hello, World!"`` program was introduced in the earlier section, and
+the *"Hello, World!"* in the print statement is a string. A string is basically
+a set of characters. Strings can be represented in various ways shown below:
+
+::
+
+ s = 'this is a string' # a string variable can be represented using single quotes
+ s = 'This one has "quotes" inside!' # The string can have quotes inside it as shown
+ s = "I have 'single-quotes' inside!"
+ l = "A string spanning many lines\
+ one more line\
+ yet another" # a string can span more than a single line.
+ t = """A triple quoted string does # another way of representing multiline strings.
+ not need to be escaped at the end and
+ "can have nested quotes" etc."""
+
+Try the following on the interpreter:
+``s = 'this is a string with 'quotes' of similar kind'``
+
+**Exercise: How to use single quotes within single quotes in a string as shown
+in the above example without getting an error?**
+
+String operations
+-----------------
+
+A few basic string operations are presented here.
+
+**String concatenation**
+String concatenation is done by simple addition of two strings.
+
+::
+
+ >>> x = 'Hello'
+ >>> y = ' Python'
+ >>> print x+y
+ Hello Python
+
+*Try this yourself:*
+
+::
+
+ >>> somenum = 13
+ >>> print x+somenum
+
+The problem with the above example is that here a string variable and an integer
+variable are trying to be concantenated. To obtain the desired result from the
+above example the str(), repr() and the `` can be used.
+
+**str()** simply converts a value to a string in a reasonable form.
+**repr()** creates a string that is a representation of the value.
+
+The difference can be seen in the example shown below:
+
+::
+
+ >>> str(1000000000000000000000000000000000000000000000000L)
+ '1000000000000000000000000000000000000000000000000'
+ >>> repr(1000000000000000000000000000000000000000000000000L)
+ '1000000000000000000000000000000000000000000000000L'
+
+It can be observed that the 'L' in the long value shown was omitted by str(),
+whereas repr() converted that into a string too. An alternative way of using
+repr(value) is ```value```.
+
+A few more examples:
+::
+
+ >>> x = "Let's go \nto Pycon"
+ >>> print x
+ Let's go
+ to Pycon
+
+In the above example, notice that the '\n'(newline) character is formatted and
+the string is printed on two lines. The strings discussed until now were normal
+strings. Other than these there are two other types of strings namely, raw strings
+and unicode strings.
+
+**Raw strings** are strings which are unformatted, that is the backslashes(\) are
+not parsed and are left as it is in the string. Raw strings are represented with
+an 'r' at the start of a string.
+Let us look at an example
+
+::
+
+ >>> x = r"Let's go \nto Pycon"
+ >>> print x
+ Let's go \nto Pycon
+
+Note: The '\n' is not being parsed into a new line and is left as it is.
+
+*Try this yourself:*
+
+::
+
+ >>> x = r"Let's go to Pycon\"
+
+**Unicode strings** are strings where the characters are Unicode characters as
+opposed to ASCII characters. Unicode strings are represented with a 'u' at the
+start of the string.
+Let us look at an example:
+
+::
+
+ >>> x = u"Let's go to Pycon!"
+ >>> print x
+ Let's go to Pycon!
+
+Boolean
+~~~~~~~
+
+Python also provides special Boolean datatype. A boolean variable can assume a
+value of either *True* or *False* (Note the capitalizations).
+
+Let us look at examples:
+
+::
+
+ >>> t = True
+ >>> f = not t
+ >>> print f
+ False
+ >>> f or t
+ True
+ >>> f and t
+ False
+
+The **while** loop
+==================
+
+
+The Python **while** loop is similar to the C/C++ while loop. The syntax is as
+follows:
+
+::
+
+ statement 0
+ while condition:
+ statement 1 #while block
+ statement 2 #while block
+ statement 3 #outside the while block.
+
+Let us look at an example:
+
+::
+
+ >>> x = 1
+ >>> while x <= 5:
+ ... print x
+ ... x += 1
+ ...
+ 1
+ 2
+ 3
+ 4
+ 5
+
+The **if** conditional
+======================
+
+The Python **if** block provides the conditional execution of statements.
+If the condition evaluates as true the block of statements defined under the if
+block are executed.
+
+If the first block is not executed on account of the condition not being satisfied,
+the set of statements in the **else** block are executed.
+
+The **elif** block provides the functionality of evaluation of multiple conditions
+as shown in the example.
+
+The syntax is as follows:
+
+::
+
+ if condition :
+ statement_1
+ statement_2
+
+ elif condition:
+ statement_3
+ statement_4
+ else:
+ statement_5
+ statement_6
+
+Let us look at an example:
+
+::
+
+ >>> n = raw_input("Input a number:")
+ >>> if n < 0:
+ print n," is negative"
+ elif n > 0:
+ print n," is positive"
+ else:
+ print n, " is 0"
+
+**raw_input()**
+===============
+
+In the previous example we saw the call to the raw_input() subroutine.
+The **raw_input()** method is used to take user inputs through the console.
+Unlike **input()** which assumes the data entered by the user as a standard python
+expression, **raw_input()** treats all the input data as raw data and converts
+everything into a string. To illustrate this let us look at an example.
+
+::
+
+ >>> input("Enter a number thats a palindrome:")
+ Enter a number thats a palindrome:121
+ 121
+
+ >>> input("Enter your name:")
+ Enter your name:PythonFreak
+ Traceback (most recent call last):
+ File "<stdin>", line 1, in <module>
+ File "<string>", line 1, in <module>
+ NameError: name 'PythonFreak' is not defined
+
+As shown above the **input()** assumes that the data entered is a valid Python
+expression. In the first call it prompts for an integer input and when entered
+it accepts the integer as an integer, whereas in the second call, when the string
+is entered without the quotes, **input()** assumes that the entered data is a valid
+Python expression and hence it raises and exception saying PythonFreak is not
+defined.
+
+::
+
+ >>> input("Enter your name:")
+ Enter your name:'PythonFreak'
+ 'PythonFreak'
+ >>>
+
+Here the name is accepted because its entered as a string (within quotes). But
+its unreasonable to go on using quotes each time a string is entered. Hence the
+alternative is to use **raw_input()**.
+
+Let us now look at how **raw_input()** operates with an example.
+
+::
+
+ >>> raw_input("Enter your name:")
+ Enter your name:PythonFreak
+ 'PythonFreak'
+
+Observe that the **raw_input()** is converting it into a string all by itself.
+
+::
+
+ >>> pal = raw_input("Enter a number thats a palindrome:")
+ Enter a number thats a palindrome:121
+ '121'
+
+Observe that **raw_input()** is converting the integer 121 also to a string as
+'121'. Let us look at another example:
+
+::
+
+ >>> pal = raw_input("Enter a number thats a palindrome:")
+ Enter a number thats a palindrome:121
+ >>> pal + 2
+ Traceback (most recent call last):
+ File "<stdin>", line 1, in <module>
+ TypeError: cannot concatenate 'str' and 'int' objects
+ >>> pal
+ '121'
+
+Observe here that the variable *pal* is a string and hence integer operations
+cannot be performed on it. Hence the exception is raised.
+
+**int()** method
+================
+
+Generally for computing purposes, the data used is not strings or raw data but
+on integers, floats and similar mathematical data structures. The data obtained
+from **raw_input()** is raw data in the form of strings. In order to obtain integers
+from strings we use the method **int()**.
+
+Let us look at an example.
+
+::
+
+ >>> intpal = int(pal)
+ >>> intpal
+ 121
+
+In the previous example it was observed that *pal* was a string variable. Here
+using the **int()** method the string *pal* was converted to an integer variable.
+
+*Try This Yourself:*
+
+::
+
+ >>> stringvar = raw_input("Enter a name:")
+ Enter a name:Guido Van Rossum
+ >>> stringvar
+ 'Guido Van Rossum'
+ >>> numvar = int(stringvar)
+