Table of Contents
+ +Table of Contents
+ +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.
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.
+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
+. 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:
+Doc:
+Official Python Tutorial:
+Byte of Python:
+Dive into Python:
+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 +
+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.
+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
+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.
+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
+Python provides the following set of basic datatypes.
+Numbers: int, float, long, complex
Strings
Boolean
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 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 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?
+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!+
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 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"
+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.
+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)
+