Python data manipulations with operations

Type

In Python an easy way to check what type of a value you have is to use one of the the Python’s build-in functions type(). Let us take a look at how we can use it for various types of values:

>>> type("hello ams 209!")
<type 'str'>

>>> type(159)
<type 'int'>

>>> type(1.59)
<type 'float'>

>>> type('1.59')
<type 'str'>

>>> a=[1,2,3]
>>> type(a)
<type 'list'>
>>> id(a)
4303245536

>>> a=(1,2,3)
>>> type(a)
<type 'tuple'>
>>> id(a)
4303122336

Python keywords

There are 31 keywords in Python 2 that are prohibited from using them as variable names in codes:

and
as
assert
break
class
continue
def
del
elif
else
except
exec
finally
for
from
global
if
import
in
is
lambda
not
or
pass
print
raise
return
try
while
with
yield

In Python 3, exec is no longer a keyword, but nonlocal is. If the interpreter complains about one of your variable names and you are not sure why, see if it is on this list.

Operators and operands

The operators include:
  • + (addition):

    >>> 5 + 3.1
    8.1
    
  • - (subtraction):

    >>> 5-3
    2
    >>> 5.0-3
    2.0
    >>> 5.-3.
    2.0
    >>> 0+213
    213
    >>> 0+0213
    139
    >>> 0218
    File "<stdin>", line 1
    0218
          ^
    SyntaxError: invalid token # why???
    

See how to create integers in binary, octal, and hexadecimal forms:

  • * (multiplication):

    >>> 4*3
    12
    >>> 4.*3
    12.0
    >>>1*2132
    2132
    >>> 1*02132
    1114   # why???
    
  • / (division):

    >>> 3/5
    0
    >>> 3./5
    0.6
    >>> 3/5.
    0.6
    
  • ** (exponentiation, not ^):

    >>> 5**2
    25
    >>> 5**2.
    25.0
    
  • // (floor division – chops off the fraction part):

    >>> 5.//3.
    1.0
    >>> 5./3.
    1.6666666666666667
    
  • % (modulus operator):

    >>> remainder = 7 % 3
    >>> print remainder
    1
    >>> remainder = 7 % 3.
    >>> print remainder
    1.0
    

In the above we note that when two operands are both integers the result is also integer; if at least one of them is real (float) the result is real.

Data manipulations

We can also form a list whose elements are not the same type. For instance:

>>> a=[1,'b',1.59,"hello ams 209",(-1,3,5),[1,(2,'apple')]]
>>> type(a)            # which is a
<type 'list'>

>>> type(a[1])         # which is 'b'
<type 'str'>

>>> type(a[-1])        # which is [1,(2,'apple')]
<type 'list'>

>>> type(a[-1][0])     # which is 1
<type 'int'>

>>> type(a[-1][1])     # which is (2,'apple')
<type 'tuple'>

>>> type(a[-1][1][1])  # which is 'apple'
<type 'str'>

>>> type(a[-1][1][0])  # which is 2
<type 'int'>

Since a list is mutable, we can easily modify it:

>>> a.append(True)
>>> type(a[-1])
<type 'bool'>

>>> b = ['we love scientific computing', 'my grade will be', 'A',209]
>>> a.extend(b)
>>> a
[1, 'b', 1.59, 'hello ams 209', (-1, 3, 5), [1, (2, 'apple')], True, 'we love scientific computing', 'my grade will be', 'A', 209]
>>> a[3],a[7],a[8:9]
('hello ams 209', 'we love scientific computing', ['my grade will be'])

>>> a[3],a[7],a[8:10]
('hello ams 209', 'we love scientific computing', ['my grade will be', 'A'])

>>> a[3],a[7],a[8]+' '+a[9]
('hello ams 209', 'we love scientific computing', 'my grade will be A')

Note

What is the difference between a.append(b) and a.extend(b)?

Now let’s change your grade from A to A+:

>>> for i, value in enumerate(a):
...     if value is 'A':
...             print i,value
...             a[i] = 'A+'
...
9 A

>>> a
[1, 'b', 1.59, 'hello ams 209', (-1, 3, 5), [1, (2, 'apple')], True,'we love scientific computing', 'my grade will be', 'A+', 209]

which will upgrade your grade from A to A+, even with a better output style as a regular sentence instead of a list this time:

>>> a[3]+', '+a[7] +', ' + a[8]+' '+a[9] +'!'
'hello ams 209, we love scientific computing, my grade will be A+!'

Now you are wondering if you can change we to I in order to express your strong love and passion of AMS209 much better. So, you first check:

>>> a[7][0:2]
'we'

Bravo! It may look like you can simply replace a[7][0:2] with I then! Now you try:

>> a[7][0:2] = 'I'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignments

This happens because the Python’s string is not mutable, it is immutable. Sigh... But let’s not worry. We can still do the following:

>>> b='I' + a[7][2:]
>>> b
'I love scientific computing'

We can now complete the task as we wanted:

>>> a[7] = b
>>> a
[1, 'b', 1.59, 'hello ams 209', (-1, 3, 5), [1, (2, 'apple')], True,'I love scientific computing', 'my grade will be', 'A+', 209]
>>> a[3]+', '+a[7] +', ' + a[8]+' '+a[9] +'!'
'hello ams 209, I love scientific computing, my grade will be A+!'

Let’s play around the list a bit more. This time, let’s think about how we can capitalize some characters of the elements in a, say, we wish to change the first alphabet h to H and ams to AMS. In this case we can use Python’s built-in function upper which invokes on the given string, in this case, a[3]. For instance:

>>> b=a[3].upper()
>>> b
'HELLO AMS 209'

Wait a minute! This just changed all of the characters in the string into capital letters. Can we fix it? We can use the similar approach as we replaced we with I in the above:

>>> c=b[0]+a[3][1:5]+b[5:]
>>> c
'Hello AMS 209'
>>> a[3]=c
>>> a
[1, 'b', 1.59, 'Hello AMS 209', (-1, 3, 5), [1, (2, 'apple')], True,'I love scientific computing', 'my grade will be', 'A+', 209]
>>>  a[3]+', '+a[7] +', ' + a[8]+' '+a[9] +'!'
'Hello AMS 209, I love scientific computing, my grade will be A+!'

Another way is to use two string methods split and list as below:

>>> k=b.split()
>>> k
['HELLO', 'AMS', '209']
>>> list(k[0])
['H', 'E', 'L', 'L', 'O']

The above two lines can be collapsed into one:

>>> k0=list(b.split()[0])
>>> k0
['H', 'E', 'L', 'L', 'O']

Let’s proceed more with two string methods of append and lower:

>>> update=[]
>>> for i,value in enumerate(k0):
...     if i > 0:
...             update.append(value.lower())
...     else:
...             update.append(value)
...
>>> update
['H', 'e', 'l', 'l', 'o']

We now need an inverse of split, which can be done by using string method called join in order to concatenate the elements of update. When doing so, it is useful to invoke the method on the delimiter and pass the list as a parameter:

>>> delimiter = ''            # delimiter is a string with no space.
>>> d=delimiter.join(update)
>>> d
'Hello'

You can also use a different spacing:

>>> delimiter2 = ' '          # delimiter1 is a string with one space.
>>> delimiter.join(update[0:2]) + delimiter2.join(update[2:])
'Hel l o'

We now replace the first element of k with d:

>>> k[0]=d
>>> k
['Hello', 'AMS', '209']

Using a delimiter, this time with - between the elements, we have:

>>> delimiter = '-'
>>> kNew=delimiter.join(k)
>>> kNew
'Hello-AMS-209'

Let us finish our task now slightly different way, using a list method del:

>>> a
[1, 'b', 1.59, 'Hello AMS 209', (-1, 3, 5), [1, (2, 'apple')], True, 'I love scientific computing', 'my grade will be', 'A+', 209]
>>> a[3]=kNew
>>> a
[1, 'b', 1.59, 'Hello-AMS-209', (-1, 3, 5), [1, (2, 'apple')], True, 'I love scientific computing', 'my grade will be', 'A+', 209]
>>> del a[0:3]
>>> a
['Hello-AMS-209', (-1, 3, 5), [1, (2, 'apple')], True, 'I love scientific computing', 'my grade will be', 'A+', 209]
>>> del a[1:4]
>>> a
['Hello-AMS-209', 'I love scientific computing', 'my grade will be', 'A+', 209]
>>> del a[-1]
>>> a
['Hello-AMS-209', 'I love scientific computing', 'my grade will be', 'A+']

Using a space as a delimiter again, we get:

>>> delimiter=' '
>>> delimiter.join(a)
'Hello-AMS-209 I love scientific computing my grade will be A+'

One can always split characters with word boundaries defined by delimiter. If we wish to split Hello-AMS-200, we can do:

>>> a[0]
'Hello-AMS-209'
>>> delimiter='-'
>>> f=a[0].split(delimiter)
>>> f
['Hello', 'AMS', '209']

Again, if we invoke join on a string with one empty space '':

>>> ' '.join(f)    # Note here we directly used ' ' instead of using a variable delimiter to define it.
'Hello AMS 209'