diff -r 000000000000 -r 27e1f5bd2774 sttp/basic_python/intro.rst~ --- /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 "", 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 `` 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 "", line 1, in + File "", line 1, in + 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 "", line 1, in + 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) +