02 Python basics

This is part of Python for Geosciences notes.

================

Python is a widely used general-purpose, high-level programming language. Its design philosophy emphasizes code readability, and its syntax allows programmers to express concepts in fewer lines of code than would be possible in languages such as C. The language provides constructs intended to enable clear programs on both a small and large scale.

-- From Wikipedia, the free encyclopedia

Variables

Python uses duck typing

Int

In [2]:
a = 10
In [4]:
a
Out[4]:
10
In [5]:
type(a)
Out[5]:
int

Float

In [6]:
z = 10.
z
Out[6]:
10.0
In [7]:
type(z)
Out[7]:
float

String

In [8]:
b = '2'
b
Out[8]:
'2'

Some operations are not allowed on different types:

In [9]:
a+b
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-9-f1d53b280433> in <module>()
----> 1 a+b

TypeError: unsupported operand type(s) for +: 'int' and 'str'

But some of them are allowed:

In [10]:
a*b
Out[10]:
'2222222222'

Might be a source of confusion :)

String variables can be combined:

In [11]:
c = ' guys walk into a bar'
c
Out[11]:
' guys walk into a bar'
In [12]:
b+c
Out[12]:
'2 guys walk into a bar'

In order to include variable of another type in to string you have to convert it:

In [13]:
str(a)+c
Out[13]:
'10 guys walk into a bar'

Everything is an object

In IPython you can get the list of object's methods and attributes by typing dot and pressing TAB:

In [14]:
c.
Out[14]:
' guys walk into a bar'

Methods are basically default functions that can be applied to our variable:

In [15]:
c.upper()
Out[15]:
' GUYS WALK INTO A BAR'
In [16]:
c.title()
Out[16]:
' Guys Walk Into A Bar'
In [17]:
c.count('a')
Out[17]:
3
In [18]:
c.find('into')
Out[18]:
11

If you need help on method in IPython type something like:

In [ ]:
c.find?

Or open bracket and press TAB:

In [ ]:
c.find(

Int variable is also an object:

In [19]:
a.bit_length()
Out[19]:
4

Methods can be combined (kind of a pipeline)

In [22]:
c.title().count('a').bit_length()
Out[22]:
2

Lists

There are several other interesting variable types in Python, but the one we would need the most is the list.

In order to create list put coma separated values in square brackets:

In [23]:
l = [1,2,3,4,5]
l
Out[23]:
[1, 2, 3, 4, 5]

Sort of similar to Matlab variables, but not exactly.

Values in list can be any type:

In [24]:
l = ['one', 'two', 'three', 'four', 'five']
l
Out[24]:
['one', 'two', 'three', 'four', 'five']

Combined

In [25]:
l = ['one', 2, 'three', 4.0, 3+2]
l
Out[25]:
['one', 2, 'three', 4.0, 5]

Any type means ANY type:

In [1]:
l = ['one', 2, 'three', [1,2,3,4,5], 3+2]
l
Out[1]:
['one', 2, 'three', [1, 2, 3, 4, 5], 5]

You can access list values by index:

In [27]:
l[0]
Out[27]:
'one'

Oh, yes, indexing starts with zero, so for Matlab users the zero is the new one :) See discussion on the matter here.

In [28]:
l[1]
Out[28]:
2

Let's have a look at the 4th element of our list:

In [30]:
l[3]
Out[30]:
[1, 2, 3, 4, 5]

It's also a list, and its values can be accessed by indexes as well:

In [31]:
l[3][4]
Out[31]:
5

You also can acces multiple elements of the list using slices:

In [32]:
l[1:3]
Out[32]:
[2, 'three']

Slice will start with the first slice index and go up to but not including the second slice index.

In [2]:
l[3]
Out[2]:
[1, 2, 3, 4, 5]

Control Structures

For loop:

This loop will print all elements from the list l

In [3]:
l = ['one', 2, 'three', [1,2,3,4,5], 3+2]

for element in l:
    print element
one
2
three
[1, 2, 3, 4, 5]
5

Two interesting thins here. First: indentation, it's in the code, you must use it, otherwise code will not work:

In [34]:
for element in l:
print element
  File "<ipython-input-34-7d2140ae42dc>", line 2
    print element
        ^
IndentationError: expected an indented block

Second - you can iterate through the elements of the list. There is an option to iterate through a bunch of numbers as we used to in Matlab:

In [36]:
for index in range(5):
    print(l[index])
one
2
three
[1, 2, 3, 4, 5]
5

where range is just generating a list with sequence of numbers:

In [35]:
range(5)
Out[35]:
[0, 1, 2, 3, 4]

Branches

We are not going to use branches in this notes, but this is how they look like just as another example of indentation use:

In [37]:
x = -1
if x > 0:
   print "Melting"
elif x == 0:
   print "Zero"
else:
   print "Freezing"
Freezing

Modules

Pure python does not do much. Even IPython with pylab enabled can do only limited number of things. To do some specific tasks you need to import modules. Here I am going to demonstrate several ways to do so.

The most common one is to import complete library. In this example we import urllib2 - a library for opening URLs using a variety of protocols.

In [5]:
import urllib2

Here we get information from some ftp site. Note how function urlopen is called. We have to use name of the library, then dot, then name of the function from the library:

In [8]:
response = urllib2.urlopen('ftp://ftp.zmaw.de/')
html = response.read()
html.splitlines()
Out[8]:
['dr-xr-x---  17 ftp      ftp         20480 Oct 26 03:15 incoming',
 'dr-xr-x---  51 ftp      ftp         12288 Oct 26 03:30 outgoing']

Another option is to import it like this:

In [9]:
from urllib2 import *

In this case all functions will be imported in to the name-space and you can use urlopen directly, without typing the name of the library first:

In [10]:
response = urlopen('ftp://ftp.zmaw.de/')
html = response.read()
html.splitlines()
Out[10]:
['dr-xr-x---  17 ftp      ftp         20480 Oct 26 03:15 incoming',
 'dr-xr-x---  51 ftp      ftp         12288 Oct 26 03:30 outgoing']

But generally I think it's a bad idea, because your name-space is populated by things that you don't really need and it's hard to tell where the function comes from.

In [43]:
whos
Variable                          Type                          Data/Info
-------------------------------------------------------------------------
AbstractBasicAuthHandler          classobj                      urllib2.AbstractBasicAuthHandler
AbstractDigestAuthHandler         classobj                      urllib2.AbstractDigestAuthHandler
AbstractHTTPHandler               classobj                      urllib2.AbstractHTTPHandler
BaseHandler                       classobj                      urllib2.BaseHandler
CacheFTPHandler                   classobj                      urllib2.CacheFTPHandler
FTPHandler                        classobj                      urllib2.FTPHandler
FileHandler                       classobj                      urllib2.FileHandler
HTTPBasicAuthHandler              classobj                      urllib2.HTTPBasicAuthHandler
HTTPCookieProcessor               classobj                      urllib2.HTTPCookieProcessor
HTTPDefaultErrorHandler           classobj                      urllib2.HTTPDefaultErrorHandler
HTTPDigestAuthHandler             classobj                      urllib2.HTTPDigestAuthHandler
HTTPError                         type                          <class 'urllib2.HTTPError'>
HTTPErrorProcessor                classobj                      urllib2.HTTPErrorProcessor
HTTPHandler                       classobj                      urllib2.HTTPHandler
HTTPPasswordMgr                   classobj                      urllib2.HTTPPasswordMgr
HTTPPasswordMgrWithDefaultRealm   classobj                      urllib2.HTTPPasswordMgrWithDefaultRealm
HTTPRedirectHandler               classobj                      urllib2.HTTPRedirectHandler
HTTPSHandler                      classobj                      urllib2.HTTPSHandler
OpenerDirector                    classobj                      urllib2.OpenerDirector
ProxyBasicAuthHandler             classobj                      urllib2.ProxyBasicAuthHandler
ProxyDigestAuthHandler            classobj                      urllib2.ProxyDigestAuthHandler
ProxyHandler                      classobj                      urllib2.ProxyHandler
Request                           classobj                      urllib2.Request
StringIO                          builtin_function_or_method    <built-in function StringIO>
URLError                          type                          <class 'urllib2.URLError'>
UnknownHandler                    classobj                      urllib2.UnknownHandler
a                                 int                           10
addinfourl                        classobj                      urllib.addinfourl
b                                 str                           2
base64                            module                        <module 'base64' from '/u<...>ib/python2.7/base64.pyc'>
bisect                            module                        <module 'bisect' from '/u<...>ib/python2.7/bisect.pyc'>
build_opener                      function                      <function build_opener at 0x323b578>
c                                 str                            guys walk into a bar
element                           int                           5
ftpwrapper                        classobj                      urllib.ftpwrapper
getproxies                        function                      <function getproxies_environment at 0x1ef1050>
hashlib                           module                        <module 'hashlib' from '/<...>b/python2.7/hashlib.pyc'>
\n
httplib                           module                        <module 'httplib' from '/<...>b/python2.7/httplib.pyc'>
index                             int                           4
install_opener                    function                      <function install_opener at 0x323b230>
l                                 list                          n=5
localhost                         function                      <function localhost at 0x1eb1e60>
mimetools                         module                        <module 'mimetools' from <...>python2.7/mimetools.pyc'>
os                                module                        <module 'os' from '/usr/lib/python2.7/os.pyc'>
parse_http_list                   function                      <function parse_http_list at 0x323e7d0>
parse_keqv_list                   function                      <function parse_keqv_list at 0x323cd70>
posixpath                         module                        <module 'posixpath' from <...>python2.7/posixpath.pyc'>
proxy_bypass                      function                      <function proxy_bypass_environment at 0x1ef10c8>
quote                             function                      <function quote at 0x1ee5e60>
randombytes                       function                      <function randombytes at 0x323c668>
re                                module                        <module 're' from '/usr/lib/python2.7/re.pyc'>
request_host                      function                      <function request_host at 0x323b2a8>
response                          urllib.addinfourl             <addinfourl at 54345600 w<...>ct object at 0x33af350>>>
socket                            module                        <module 'socket' from '/u<...>ib/python2.7/socket.pyc'>
splitattr                         function                      <function splitattr at 0x1ee5c80>
splithost                         function                      <function splithost at 0x1ee5938>
splitpasswd                       function                      <function splitpasswd at 0x1ee5a28>
splitport                         function                      <function splitport at 0x1ee5aa0>
splittag                          function                      <function splittag at 0x1ee5c08>
splittype                         function                      <function splittype at 0x1ee58c0>
splituser                         function                      <function splituser at 0x1ee59b0>
splitvalue                        function                      <function splitvalue at 0x1ee5cf8>
time                              module                        <module 'time' (built-in)>
unquote                           function                      <function unquote at 0x1ee5d70>
url2pathname                      function                      <function url2pathname at 0x1eb1938>
urllib2                           module                        <module 'urllib2' from '/<...>b/python2.7/urllib2.pyc'>
urlopen                           function                      <function urlopen at 0x3238b90>
urlparse                          module                        <module 'urlparse' from '<...>/python2.7/urlparse.pyc'>
x                                 int                           -1
z                                 float                         10.0

You can import only function that you need:

In [ ]:
from urllib2 import urlopen
In [44]:
response = urlopen('ftp://ftp.zmaw.de/')
html = response.read()
html.splitlines()
Out[44]:
['dr-xr-x---  16 ftp      ftp         20480 Oct 23 15:51 incoming',
 'dr-xr-x---  49 ftp      ftp         12288 Oct 23 03:30 outgoing']

Or import library as alias in order to avoid extensive typing:

In [11]:
import urllib2 as ul
In [12]:
response = ul.urlopen('ftp://ftp.zmaw.de/')
html = response.read()
html.splitlines()
Out[12]:
['dr-xr-x---  17 ftp      ftp         20480 Oct 26 03:15 incoming',
 'dr-xr-x---  51 ftp      ftp         12288 Oct 26 03:30 outgoing']

Links:

Comments !

links

social