Python Tutorial

Welcome to our Python Tutorial. We’ll cover the basics here and link to more in depth resources along the way. We hope you enjoy the tutorial and walk away with a better understanding of the Python programming language. Let’s get started with our introduction to Python for beginners!

1. Download and Install Python
2. Variables
3. Functions
4. Comments
5. Docstrings
6. Escape Characters
7. Numbers
8. Keywords
9. Strings
10. Style Rules
11. Booleans
12. Loops
13. Lists
14. Operators
15. Conditional Statements
16. Exception Handling
17. Dictionaries
18. Modules
19. Taking Input From The User

Download and Install Python

Python is a interpreted language which means that the code is translated (interpreted) to binary code while the program runs. That is different from compiled languages (C++ etc.) where the code is first compiled to binary code.

To run Python code you need to have a Python interpreter. There are different versions of Python, either Python 2 or Python 3. To see that the difference are and to decide which one to use, please see this wiki page at python.org.

Installing Python

Python is available on most operating system, (Linux, Unix, Mac OS X and Windows).

Installing it on your computer is very easy, and on some systems it’s already there.

To see if it’s already installed, open up a terminal and run this command below.

If you see a response from a Python interpreter it will include a version number in its initialdisplay.

>> python
Python 2.7.2 (default, Jun 20 2012, 16:23:33)

If you don’t have Python installed, you can take a look at this link on how to install it on the platform that you use.
http://www.diveintopython.net/installing_python/index.html

How do I run my code?

There are two ways to run the programs in Python. Either you type in the code directly in
the Python shell. When doing that you will see the result of every command that you type
in. This works best for very short programs or for testing purpose. The other way to run
the code is within a script.

Python Shell

When you are in the Python Shell, the python interpreter will translate all code for you.

To leave the help mode and return to the interpreter, we use the quit command.

The help command provides some help about Python.

>>> help
Type help() for interactive help, or help(object) for help about object.
>>>

You can also use the Python Shell for doing math
(please see my earlier post about using math in Python)

>>> 2 + 4
6
>>> 5 * 56
280
>>> 5 - 45
-40
>>> 

To exit the Python Shell, press Ctrl+d.

Python Script

To run the program as script, open an text editor (vi, pico, nano etc.) and put in the
following code:

#!/usr/bin/python  
print "hello world"

Save the file as hello.py and exit the editor.

# To execute the program, type python and the file name in the shell. 
$python hello.py

The output should be:
hello world
 

Python scripts can be made directly executable, like shell scripts, by putting the shebang
at the beginning of the script and give the file an executable mode. The shebang is meant
for the script to recognize the interpretor type when you want to execute the script from
the shell.

# The script can be given an executable mode, or permission, using the chmod command:
$ chmod +x hello.py

Now you can execute the script directly by its name.

Variables

In Python, variables are a storage placeholder for texts and numbers.

It must have a name so that you are able to find it again.

The variable is always assigned with the equal sign, followed by the value of the
variable.

Python is dynamically typed, which means that you don’t have to declare what
type each variable is.

The variables are being referred in the program to get the value of it.

The value of the variable can be changed later on.

Store the value 10 in a variable named foo
foo = 10

Store the value of foo+10 in a variable named bar
bar = foo + 10

#List of some different variable types:
x = 123      # integer
x = 123L     # long integer
x = 3.14      # double float
x = "hello"       # string
x = [0,1,2]       # list
x = (0,1,2)       # tuple
x = open(‘hello.py’, ‘r’)  # file

#You can also assign a single value to several variables simultaneously.
# variable a,b and c are assigned to the same memory location,with the value of 1
a = b = c = 1  

Get Area using Python Variables

length = 1.10
width  = 2.20
area   = length * width
print "The area is: " , area

This will print out:

The area is:  2.42

Functions

A function is something you can call (possibly with some parameters, the things you put in the parentheses), which performs an action and returns a value.

Functions are useful because:

• Reuse code
• Easy to debug
• Smaller unit of code(relatively speaking)

Function syntax

A function must be defined before it is called. To define a function, use the following syntax:

def myFunction():

The above function has no parameters, meaning no values are being passed into the function. To name parameters, use the following syntax.

def myFunction(name,age):

Now we have a function call that passes in a few parameters. We’ll move onto the body of the function and use those parameters.

def myFunction(name,age):
   print 'Name: ' + name
   print 'Age: ' + age

With our function body, the code MUST be indented. The method, when called, would print the name and age passed into it.

Instead of printing a value, a function can return that value to the program.

def myFunction(name,age):
   return 'My name is ' + name + ' and I am ' + age + ' years old'

>>> myFunction('John','44'):
'My name is John and I am 44 years old'

Return is the common conclusion of a function as the calling program will typical store its contents into a variable or act on the return value in a conditional statement.

Comments

Comments in Python are used to explain what the code does.

They are meant as documentation for anyone reading the code.

Python is automatically ignoring all text that comes after the “#”

Comments can be in the beginning of the line or at the end of one.

Multiline comments are possible and are enclosed by triple quotes.

# First comment
print "Hello, Python!";  # second comment
#this is a comment in Python
 
""" This is an example of a multiline
comment that spans multiple lines
...
"""

Docstrings

Python documentation strings (or docstrings) provide a convenient way of
associating documentation with Python modules, functions, classes, and methods.

An object’s docsting is defined by including a string constant as the first
statement in the object’s definition.

It’s specified in source code that is used, like a comment, to document a
specific segment of code.

Unlike conventional source code comments the docstring should describe what the
function does, not how.

All functions should have a docstring

This allows the program to inspect these comments at run time, for instance as an interactive help system, or as metadata.

Docstrings can be accessed by the doc attribute on objects.

How should a Docstring look like?

The doc string line should begin with a capital letter and end with a period.

The first line should be a short description.

Don’t write the name of the object.

If there are more lines in the documentation string, the second line should be
blank, visually separating the summary from the rest of the description.

The following lines should be one or more paragraphs describing the object’s
calling conventions, its side effects, etc.

Docstring Example

Here is an example of a multi-line docstring:

def my_function():
...     """Do nothing, but document it.
...
...     No, really, it doesn't do anything.
...     """
...     pass
...

Now that we have created our Docstring in the my_function() method, let’s see how it can be useful. Let’s say I’m a new developer in a project and I want to know what my_function() does. See below using the print function.

>>> print my_function.__doc__
Do nothing, but document it.

    No, really, it doesn't do anything.

Multiple Docstrings In One Source File

The following Python file shows the declaration of docstrings within a python
source file. You can clearly see the different levels of docstrings and how they can be used within a single source file.

"""
Assuming this is file mymodule.py, then this string, being the
first statement in the file, will become the "mymodule" module's
docstring when the file is imported.
"""
 
class MyClass(object):
    """The class's docstring"""
 
    def my_method(self):
        """The method's docstring"""
 
def my_function():
    """The function's docstring"""

How to access the Docstring

Below we show you two methods you can use to access the docstring.

>>> import mymodule
>>> help(mymodule)

Assuming this is file mymodule.py then this string, being the
first statement in the file will become the mymodule modules
docstring when the file is imported

>>> help(mymodule.MyClass)
The class's docstring

>>> help(mymodule.MyClass.my_method)
The method's docstring

>>> help(mymodule.my_function)
The function's docstring

Docstrings vs Comments

Docstrings and comments are similar in nature, but serve a different purpose. Comments are great for describing lines of code and why they are there. This is very helpful in large code sets.

Docstrings document what a class, module or package does and most importantly, is available to the help function, whereas, comments are not.

Docstrings, therefore, can help to document the code programmatically.

Escape Characters

Escape characters allow you to do things you normally wouldn’t be able to do following the normal Python syntax rules.

For example, you want to print this line in your code with double quotes around the title of the movie, “Titanic”.

>>> print "Cory's favorite movie is "Titanic""
SyntaxError: invalid syntax

The compiler doesn’t allow you to use double quotes inside double quotes, so you have to “escape” the double quotes from the compiler and allow them to be treated as a string.

To do this, you simply add a backslash(\) before the character you want to escape.

>>> print "Cory's favorite movie is \"Titanic\""
Cory's favorite movie is "Titanic"

Below is a table of other common escape characters.

Numbers

Python supports 4 types of Numbers, the int, the long, the float and the complex.

You don’t have to specify what type of variable you want. Python does that
automatically.

Converting Numbers

You can simply convert them, like this:

>>> float(3)
3.0
>>> int(4.123)
4

Using Python interpreter as a calculator

You can use the interpreter to do math with numbers.

>>> 2 + 2
4

>>> 4 * 2
8

>>> 10 / 2
5

>>> 10 - 2
8

Keywords

Keywords in Python are reserved words that cannot be used as ordinary identifiers. They must be spelled exactly as they are written.

List of keywords

The following is a list of keywords for the Python programming language.

x = '1,2,3'
x.split(",")
['1','2','3']

print "You can concatenate two " + "strings with the '+' operator."

 
str1 = "Hello"
str2 = "World"
str1 + str2    	# concatenation: a new string

# String literals may be concatenated by a space

word = 'left' "right" 'left'

# Any string expression may be concatenated by a +

word = wordA + "
" + wordB

Style Rules

A style guide is about consistency. Consistency with this style guide is important. Consistency within a project is more important. Consistency within one module or function is most important.

An example of this would be:

Semicolons

Do not terminate your lines with semi-colons and do not use semi-colons to put
two commands on the same line.

Line length

Maximum line length is 80 characters.

Parentheses

Use parentheses sparingly.

Indentation

Indent your code blocks with 4 spaces.

Booleans

The built-in type Boolean can hold only one of two possible objects: True or False

Boolean Values

Boolean values respond to logical operators and / or. The examples below show how multiple boolean values act together with differing operators.

>>> True and False
False

>>> True and True
True

>>> False and True
False

>>> False or True
True

>>> False or False
False