Python supports a number of built-in types and operations. This section covers the most common types, but information about additional types is available here.

The basic data numeric types are similar to those found in other languages, including:

**Integers ( int)**

In [1]:

```
i = 1
j = 219089
k = -21231
```

In [2]:

```
print(i, j, k)
```

**Floating point values ( float)**

In [3]:

```
a = 4.3
b = -5.2111222
c = 3.1e33
```

In [4]:

```
print(a, b, c)
```

**Complex values ( complex)**

In [5]:

```
d = complex(4., -1.)
```

In [6]:

```
print(d)
```

Manipulating these behaves the way you would expect, so an operation (`+`

, `-`

, `*`

, `**`

, etc.) on two values of the same type produces another value of the same type (with one, exception, `/`

, see below), while an operation on two values with different types produces a value of the more 'advanced' type:

Adding two integers gives an integer:

In [7]:

```
1 + 3
```

Out[7]:

Multiplying two floats gives a float:

In [8]:

```
3. * 2.
```

Out[8]:

Subtracting two complex numbers gives a complex number:

In [9]:

```
complex(2., 4.) - complex(1., 6.)
```

Out[9]:

Multiplying an integer with a float gives a float:

In [10]:

```
3 * 9.2
```

Out[10]:

Multiplying a float with a complex number gives a complex number:

In [11]:

```
2. * complex(-1., 3.)
```

Out[11]:

Multiplying an integer and a complex number gives a complex number:

In [12]:

```
8 * complex(-3.3, 1)
```

Out[12]:

However, the division of two integers gives a float:

In [13]:

```
3 / 2
```

Out[13]:

Note that in Python 2.x, this used to return `1`

because it would round the solution to an integer. If you ever need to work with Python 2 code, the safest approach is to add the following line at the top of the script:

```
from __future__ import division
```

and the division will then behave like a Python 3 division. Note that in Python 3 you can also specifically request integer division:

In [14]:

```
3 // 2
```

Out[14]:

The operator for raising one value to the power of another is `**`

. Try calculating $4^3$, $2+3.4^2$, and $(1 + i)^2$. What is the type of the output in each case, and does it make sense?

In [15]:

```
# enter your solution here
```

Strings (`str`

) are sequences of characters:

In [16]:

```
s = "Spam egg spam spam"
```

You can use either single quotes (`'`

), double quotes (`"`

), or triple quotes (`'''`

or `"""`

) to enclose a string (the last one is used for multi-line strings). To include single or double quotes inside a string, you can either use the opposite quote to enclose the string:

In [17]:

```
"I'm"
```

Out[17]:

In [18]:

```
'"hello"'
```

Out[18]:

or you can *escape* them:

In [19]:

```
'I\'m'
```

Out[19]:

In [20]:

```
"\"hello\""
```

Out[20]:

You can access individual characters or chunks of characters using the item notation with square brackets`[]`

:

In [21]:

```
s[5]
```

Out[21]:

Note that in Python, indexing is *zero-based*, which means that the first element in a list is zero:

In [22]:

```
s[0]
```

Out[22]:

Note that strings are **immutable**, that is you cannot change the value of certain characters without creating a new string:

In [23]:

```
s[5] = 'r'
```

You can easily find the length of a string:

In [24]:

```
len(s)
```

Out[24]:

You can use the `+`

operator to combine strings:

In [25]:

```
"hello," + " " + "world!"
```

Out[25]:

Finally, strings have many **methods** associated with them, here are a few examples:

In [26]:

```
s.upper() # An uppercase version of the string
```

Out[26]:

In [27]:

```
s.index('egg') # An integer giving the position of the sub-string
```

Out[27]:

In [28]:

```
s.split() # A list of strings
```

Out[28]:

There are several kinds of ways of storing sequences in Python, the simplest being the `list`

, which is simply a sequence of *any* Python object.

In [29]:

```
li = [4, 5.5, "spam"]
```

Accessing individual items is done like for strings

In [30]:

```
li[0]
```

Out[30]:

In [31]:

```
li[1]
```

Out[31]:

In [32]:

```
li[2]
```

Out[32]:

Values in a list can be changed, and it is also possible to append or insert elements:

In [33]:

```
li[1] = -2.2
```

In [34]:

```
li
```

Out[34]:

In [35]:

```
li.append(-3)
```

In [36]:

```
li
```

Out[36]:

In [37]:

```
li.insert(1, 3.14)
```

In [38]:

```
li
```

Out[38]:

Similarly to strings, you can find the length of a list (the number of elements) with the `len`

function:

In [39]:

```
len([1,2,3,4,5])
```

Out[39]:

We already mentioned above that it is possible to access individual elements from a string or a list using the square bracket notation. You will also find this notation for other object types in Python, for example tuples or Numpy arrays, so it's worth spending a bit of time looking at this in more detail.

In addition to using positive integers, where `0`

is the first item, it is possible to access list items with *negative* indices, which counts from the end: `-1`

is the last element, `-2`

is the second to last, etc:

In [40]:

```
li = [4, 67, 4, 2, 4, 6]
```

In [41]:

```
li[-1]
```

Out[41]:

You can also select **slices** from a list with the `start:end:step`

syntax. Be aware that the last element is *not* included!

In [42]:

```
li[0:2]
```

Out[42]:

In [43]:

```
li[:2] # ``start`` defaults to zero
```

Out[43]:

In [44]:

```
li[2:] # ``end`` defaults to the last element
```

Out[44]:

In [45]:

```
li[::2] # specify a step size
```

Out[45]:

Given a string such as the one below, make a new string that does not contain the word `egg`

:

In [46]:

```
a = "Hello, egg world!"
# enter your solution here
```

Try changing the string above to see if your solution works (you can assume that `egg`

appears only once in the string).

Most things in Python are objects. But what is an object?

Every constant, variable, or function in Python is actually a object with a
type and associated attributes and methods. An *attribute* a property of the
object that you get or set by giving the `<object_name>.<attribute_name>`

, for example `img.shape`

. A *method* is a function that the object provides, for example `img.argmax(axis=0)`

or `img.min()`

.

Use tab completion in IPython to inspect objects and start to understand attributes and methods. To start off create a list of 4 numbers:

```
li = [3, 1, 2, 1]
li.<TAB>
```

This will show the available attributes and methods for the Python list
`li`

.

**Using <TAB>-completion and help is a very efficient way to learn and later
remember object methods!**

```
In [2]: li.
li.append li.copy li.extend li.insert li.remove li.sort
li.clear li.count li.index li.pop li.reverse
```

If you want to know what a function or method does, you can use a question mark `?`

:

```
In [9]: li.append?
Type: builtin_function_or_method
String Form:<built-in method append of list object at 0x1027210e0>
Docstring: L.append(object) -> None -- append object to end
```

In the following string, find out (with code) how many times the letter "A" appears.

In [47]:

```
s = "CAGTACCAAGTGAAAGAT"
# your solution here
```

Given two lists, try making a new list that contains the elements from both previous lists:

In [48]:

```
a = [1, 2, 3]
b = [4, 5, 6]
# your solution here
```

Note that there are several possible solutions!

One final note on Python types - unlike many other programming languages where types have to be declared for variables, Python is *dynamically typed* which means that variables aren't assigned a specific type:

In [49]:

```
a = 1
type(a)
```

Out[49]:

In [50]:

```
a = 2.3
type(a)
```

Out[50]:

In [51]:

```
a = 'hello'
type(a)
```

Out[51]:

There may be cases where you want to convert a string to a floating point value, and integer to a string, etc. For this, you can simply use the `int()`

, `float()`

, and `str()`

functions:

In [52]:

```
int('1')
```

Out[52]:

In [53]:

```
float('4.31')
```

Out[53]:

For example:

In [54]:

```
int('5') + float('4.31')
```

Out[54]:

is different from:

In [55]:

```
'5' + '4.31'
```

Out[55]:

Similarly:

In [56]:

```
str(1)
```

Out[56]:

In [57]:

```
str(4.5521)
```

Out[57]:

In [58]:

```
str(3) + str(4)
```

Out[58]:

Be aware of this for example when connecting strings with numbers, as you can only concatenate identical types this way:

In [59]:

```
'The value is ' + 3
```

Instead do:

In [60]:

```
'The value is ' + str(3)
```

Out[60]:

By default, `int`

will round floating point values **down**:

In [61]:

```
int(14.99)
```

Out[61]:

If you want to round to the nearest integer, you can instead use `round`

or `np.round`

:

In [62]:

```
round(14.9)
```

Out[62]:

In Python 2, `round(14.9)`

returns `15.0`

so to be safe, you should do:

In [63]:

```
int(round(14.9))
```

Out[63]: