Week 3 - Dive Into Python, Part I¶

This week's Jupyter notebook introduces us to basic data types and actions in Python.

Without further ado, let's start:

In [1]:
# Heads-up: This is the syntax for writing comments in Python.
# Start a line with the "#" character to turn it into a comment.
# Comments are ignored by the interpreter, so you can use them for annotation purposes

# You can use the print() function to display simple data types such as numbers and strings.
print("Hello, world!")

Hello, world!

Numbers, variables and basic arithmetic¶

In [2]:
# Initialize a variable called "a" with a value of 5
a = 5
In [3]:
print(a)

5
In [4]:
# We don't have to use print() each time in notebook cells or using the interactive interpreter.
# Just using the name of a variable will also display its value:
a
Out[4]:
5

Assigning a number this way will create a variable of type int. If unsure, one can always check the type of a variable with the type() built-in method.

In [5]:
type(a)
Out[5]:
int
In [6]:
# We can change the value of a variable as follows
a = 100
In [7]:
a
Out[7]:
100
In [8]:
b = 200
# Addition is as simple as
a + b
Out[8]:
300
In [9]:
# If we want to save the result of an expression we can assign it to a variable
c = a * b - 10
c
Out[9]:
19990

Aside from the four basic arithmetic operators +, -, *, /, there exist other operators in Python as well.

One such example is the power operator (**), where a ** b can be used for calculating $a^b$:

In [10]:
a ** 5
Out[10]:
10000000000

Note: The int type is flexible in terms of representing relatively huge numbers:

In [11]:
a ** 100
Out[11]:
100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
In [12]:
type(a)
Out[12]:
int

We can also represent floating-point numbers just as easily:

In [13]:
a = 5.0
type(a)
Out[13]:
float

The following syntax also works for representing float types:

In [14]:
5.
Out[14]:
5.0
In [15]:
.5
Out[15]:
0.5

Here's an example of a complex type, which is specified by having the j suffix after the imaginary part of the number:

In [16]:
c = 3 + 4j
type(c)
Out[16]:
complex

As an example, this type comes with its own multiplication operator:

In [17]:
c * c
Out[17]:
(-7+24j)

Libraries¶

(Note: we learn about libraries more in detail, later...)

Some useful functions, such as sin() and cos(), are not directly available:

In [18]:
cos(0)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[18], line 1
----> 1 cos(0)

NameError: name 'cos' is not defined

To be able to use these functions, we have to import a library that contains them. Such useful math functions can be accessed by importing the math library, as follows:

In [19]:
import math

To use a function from a library, we use the lname.fname(...) syntax, where lname represents the imported library name and fname represents the function name. As an example:

In [20]:
math.pow(2, 5)
Out[20]:
32.0

Aside from functions, can also provide special values such as pi:

In [21]:
math.cos(math.pi)
Out[21]:
-1.0

Boolean values and logic¶

We can define variables to have the Boolean values of True and False to do logical operations.

In [22]:
a = True
In [23]:
b = False

The and binary operator evaluates to True if both of its operands are True, otherwise it evaluates to False.

In [24]:
a and b
Out[24]:
False
In [25]:
b and b
Out[25]:
False
In [26]:
a and a
Out[26]:
True

The or binary operator evalues to True if any of its operands are True, otherwise it evaluates to False.

In [27]:
a or b
Out[27]:
True
In [28]:
b or b
Out[28]:
False
In [29]:
a or a
Out[29]:
True

not negates the value of a Boolean variable.

In [30]:
not True
Out[30]:
False
In [31]:
not False
Out[31]:
True

Comparison operators (such as >, <, >=, <=, ==, !=) will return Boolean values:

In [32]:
# Equality
10 == 10
Out[32]:
True
In [33]:
3 > 5
Out[33]:
False
In [34]:
# Inequality
3 != 3.1
Out[34]:
True

Container datatypes¶

Python gives us many types for storing data. We'll explore each one, starting from strings:

Strings¶

Strings represent a sequence of characters, and are created with using enclosing single (') or double (") quotation marks:

In [35]:
s = 'hello'
type(s)
Out[35]:
str

Python allows us to do several operations with indexes, one such example being concatenation:

In [36]:
d = 'hello'
e = 'world'
d + e
Out[36]:
'helloworld'
In [37]:
# If we want a space between the words, we can do this:

d + ' ' + e
Out[37]:
'hello world'

Although both numbers and strings are able to use +, Python will not allow mixing integers with strings:

In [38]:
10 + '10'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[38], line 1
----> 1 10 + '10'

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

To convert a string into a number, we can use int():

In [39]:
10 + int(10)
Out[39]:
20

We can also check if a string contains another string inside it, using the in keyword:

In [40]:
'hello' in 'hello, world'
Out[40]:
True

Similarly, we can check if it doesn't contain such a substring, with:

In [41]:
'hello' not in 'hello, world'
Out[41]:
False

Strings are case sensitive:

In [42]:
'Hello' == 'hello'
Out[42]:
False

The len() function allows us to get the length of a string:

In [43]:
len('Hello')
Out[43]:
5
In [44]:
# Don't forget, each character (including spaces and punctuation) contributes to the length:
len('Hello, world!')
Out[44]:
13

Strings and other sequential containers allow repetition with *:

In [45]:
'hello' * 3
Out[45]:
'hellohellohello'

Indexing and Slicing¶

Sequential containers such as strings and lists allow us to access elements using their position (index) in the container. Indexing and slicing use square brackets [].

Note 1: In python, indexes start at 0. This means that the first character you see in the string has index 0, the second character has index 1, and so on.

Note 2: Python allows negative indexing. Negative indexes start by counting from the end of the string.

It's best to proceed with a simple visualization of a string (ceng240) along with its positive and negative indexes:

0 1 2 3 4 5 6 Positive indexing
c e n g 2 4 0
-7 -6 -5 -4 -3 -2 -1 Negative indexing

For example, the 'g' element can be accessed via positive indexing (3), as well as negative indexing (-4).

In [46]:
s = 'ceng240'

Simple indexing has the syntax of container[idx], which will access the element with the given index. Here are some examples with positive indexing:

In [47]:
# The "first" character has the index 0
s[0]
Out[47]:
'c'
In [48]:
s[3]
Out[48]:
'g'
In [49]:
# To access the last element, we can use
s[len(s) - 1]
Out[49]:
'0'

Here are some examples with negative indexing:

In [50]:
# First element from the end
s[-1] # not s[-0], as that is just s[0]
Out[50]:
'0'
In [51]:
s[-3]
Out[51]:
'2'

One can observe that for negative indexing, we have the following equality:

s[-idx] = s[len(s) - idx]

In [52]:
s[-5] == s[len(s) - 5]
Out[52]:
True

With the s[idx1:idx2] syntax, Python allows us to access a slice (i.e, multiple elements) of a container. The slice starts from the first index (inclusive), up to (but not including) the second index parameter.

Some examples of slicing:

In [53]:
s[0:4]
Out[53]:
'ceng'
In [54]:
s[2:3]
Out[54]:
'n'
In [55]:
# This will also work (if confused, check the table)
s[-3:-1]
Out[55]:
'24'

If idx1 is left empty, the slice will start from the start of the container.

(i.e, by default, idx1 = 0)

If idx2 is left empty, the slice will continue until the end of the container.

(i.e, by default, idx2 = length of the container)

In [56]:
# This will skip the initial element
s[1:]
Out[56]:
'eng240'
In [57]:
# And this will slice the first 5 - 1 elements of the string
s[:5]
Out[57]:
'ceng2'
In [58]:
# Get the last 3 characters of the string:
s[-3:]
Out[58]:
'240'
In [59]:
# Slice all the characters except the last 4:
s[:-3]
Out[59]:
'ceng'

(you can add additional cells under this cell to practice your slicing skills)

Finally, Python allows strided indexing, with the s[idx1:idx2:stride] syntax. The stride (or increment) parameter allows the slice to "skip over" consecutive elements of the string. After indexing the first element (with idx1), the next index will be selected by incrementing (or decrementing!) the current index with stride, and so on.

It's best to learn by example, as always:

In [60]:
# This is the usual behavior of slicing, where the next index is selected by incrementing by 1:
s[::1]
Out[60]:
'ceng240'
In [61]:
# Now, after selecting the first element, we will select every other element:
s[::2]
Out[61]:
'cn20'
In [62]:
# This will allow you to get the even numbers
'0123456789'[::2]
Out[62]:
'02468'
In [63]:
# To get the odd numbers, you could do this
'0123456789'[1::2]
Out[63]:
'13579'
In [64]:
# Classic trick to "invert" a string:
s[::-1]
Out[64]:
'042gnec'
In [65]:
# One final example of strided slicing:
'0123456789'[::-3]
Out[65]:
'9630'

Leaving the stride parameter empty is the same as setting it to 1:

In [66]:
s[::] == s[::1]
Out[66]:
True

Special characters¶

The following will not be accepted by Python, because we are trying to use quotation marks inside a string:

In [67]:
# Python will complain about this
j = "I said "hello, world""

  Cell In[67], line 2
    j = "I said "hello, world""
                 ^
SyntaxError: invalid syntax

To solve this, we can use single quotes (') to define the string, and use double quotes (") inside the string:

In [68]:
j = 'I said "hello, world"'
j
Out[68]:
'I said "hello, world"'

The same technique can be used for using single quotes in a string:

In [69]:
j = "I said 'hello, world'"
j
Out[69]:
"I said 'hello, world'"

Alternatively, we can use the backslash (\) character to make Python understand that this character should be inside the string:

In [70]:
# We escape the quotes by using \"
j = "I said \"hello, world\""
j
Out[70]:
'I said "hello, world"'

We can make multi-line strings by using the docstring syntax, where the string is enclosed by three single quotation marks ('''text''').

In [71]:
k = '''
    hello
    world
    ceng240'''

Note that this will also preserve the lines:

In [72]:
print(k)

    hello
    world
    ceng240

When we display k directly, we see the following:

In [73]:
k
Out[73]:
'\n    hello\n    world\n    ceng240'

Here, \n is what Python uses to represent a vertical line, as a special character (called the newline character). We can use it ourselves to print text in different lines as follows:

In [74]:
print("hello\nworld")

hello
world

Note: Strings are immutable, which means after we create a string, it is not possible to change its content:

In [75]:
s = 'hello'
s[0] = 'j'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[75], line 2
      1 s = 'hello'
----> 2 s[0] = 'j'

TypeError: 'str' object does not support item assignment

Here, we would create a new string:

In [76]:
'j' + s[1:]
Out[76]:
'jello'

Lists and Tuples¶

Lists (and tuples) are sequential containers that can hold data of different types inside. They are defined using square brackets [ ].

In [77]:
# Create a list of random stuff
l = ['a', 10, 'c', False]
type(l)
Out[77]:
list
In [78]:
l
Out[78]:
['a', 10, 'c', False]

As we saw with strings, we can do common operations on lists, such as slicing and indexing:

In [79]:
l[1:]
Out[79]:
[10, 'c', False]
In [80]:
l[::-1]
Out[80]:
[False, 'c', 10, 'a']

Lists can be elements of other lists, as follows:

In [81]:
l = ['1',
     2,
     'a',
     ['s', 0, 10]]
# Accessing an element in a list inside a list:
l[3][0]
Out[81]:
's'

You could represent a matrix as a list of lists:

In [82]:
a = [
    [1,2,3],
    [3,4, 5],
    [1, 10, 8]
]
a[2][2]
Out[82]:
8

Lists are mutable, which means the data inside the container can be changed after initialization:

In [83]:
l = [1, '2', 10, [1], 5]
In [84]:
l[0] = 'hello'
l
Out[84]:
['hello', '2', 10, [1], 5]

If we want the data to unchangeable after initialization, we use tuples instead, which are immutable. Tuples use parentheses () instead of square brackets.

In [85]:
t = (1, '2', 10, [1], 5)
type(t)
Out[85]:
tuple
In [86]:
t[0] = 'hello'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[86], line 1
----> 1 t[0] = 'hello'

TypeError: 'tuple' object does not support item assignment
In [87]:
# You can create a tuple from a list via tuple(), and vice versa via list()
t2 = tuple(l)
t2
Out[87]:
('hello', '2', 10, [1], 5)

As lists are mutable, we can add new elements, or remove elements from the list. In particular, [] by itself represents an empty list.

In [88]:
len([])
Out[88]:
0
In [89]:
l
Out[89]:
['hello', '2', 10, [1], 5]
In [90]:
# Remove via the del keyword
del l[0]
l
Out[90]:
['2', 10, [1], 5]
In [91]:
# Remove via accessing and setting to empty list
l[0:2] = []
l
Out[91]:
[[1], 5]

Adding elements via list.append() will add an element to the end of the list:

In [92]:
l.append(5)
l
Out[92]:
[[1], 5, 5]

Lists allow concatenation (like strings), so you can combine lists or add new elements like the following:

In [93]:
[1, 2, 3] + [4, 5, 6]
Out[93]:
[1, 2, 3, 4, 5, 6]
In [94]:
l = [9, 8, 0]
l += [4]
l
Out[94]:
[9, 8, 0, 4]
In [95]:
# Insertion at a particular index
l.insert(3, 'hello')
l
Out[95]:
[9, 8, 0, 'hello', 4]

Lists allow repetition, like strings:

In [96]:
l * 2
Out[96]:
[9, 8, 0, 'hello', 4, 9, 8, 0, 'hello', 4]

And finally, one can check for membership in lists using the in / not in syntax:

In [97]:
l = [1, 'c', 10, False, 'Hello']
1 in l
Out[97]:
True
In [98]:
2 in l
Out[98]:
False
In [99]:
False in l
Out[99]:
True
In [100]:
10 not in l
Out[100]:
False

Dict¶

Dictionaries are efficient containers which hold key-value pairs, where each key accesses a specific value in the dictionary. They are defined using curly braces {}.

In [101]:
# An empty dict
d = {}
type(d)
Out[101]:
dict

Adding a key-value pair to a dict is done by the following syntax:

In [102]:
d['key'] = 'value'
d
Out[102]:
{'key': 'value'}
In [103]:
# Adding a pair with an integer key
d[10] = True
d
Out[103]:
{'key': 'value', 10: True}

We can check if a value exists for a key by the following syntax:

In [104]:
d['key'] # Will return 'value'
Out[104]:
'value'

If the provided key does not exist, Python will complain with a KeyError:

In [105]:
d['hello']

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[105], line 1
----> 1 d['hello']

KeyError: 'hello'
In [106]:
# We can use the get() method for accesing a key-value pair as well:
d.get('key')
Out[106]:
'value'
In [107]:
# However, Python will not throw a KeyError if that key does not exist
d.get('hello')

Here's an example of a dictionary with different keys and values:

In [108]:
person = {
    'name': 'Cagri Eser',
    'email': 'cagrie@metu.edu.tr',
    'age': 26,
    'phone': 123
}
In [109]:
person['name']
Out[109]:
'Cagri Eser'

We can change the value of a key using the same syntax:

In [110]:
person['phone'] = 456
person['phone']
Out[110]:
456

And we can delete a key-value pair by specifying the key:

In [111]:
del person['age']
person
Out[111]:
{'name': 'Cagri Eser', 'email': 'cagrie@metu.edu.tr', 'phone': 456}

We can access the individual keys and values with:

In [112]:
person.keys()
Out[112]:
dict_keys(['name', 'email', 'phone'])
In [113]:
person.values()
Out[113]:
dict_values(['Cagri Eser', 'cagrie@metu.edu.tr', 456])
In [114]:
# We haven't seen for loops, but here's a sneak peek:
for key, value in person.items():
    print(key, value)

name Cagri Eser
email cagrie@metu.edu.tr
phone 456
In [115]:
# Checking for a key using the 'in' syntax
'name' in person
Out[115]:
True

Sets¶

Sets are similar to dicts, and they also use curly brackets {}. Sets are mutable, however, elements of sets must be immutable. Each element in a set can appear only once.

In [116]:
s = {1, 2, 3}
type(s)
Out[116]:
set
In [117]:
# Sets do not support indexing
s[0]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[117], line 2
      1 # Sets do not support indexing
----> 2 s[0]

TypeError: 'set' object is not subscriptable

Sets support addition and removal of new elements.

In [118]:
s.add(4)
s
Out[118]:
{1, 2, 3, 4}
In [119]:
s.add('hello')
s
Out[119]:
{1, 2, 3, 4, 'hello'}
In [120]:
# Lists can't be added to sets as they are mutable
s.add([1, 2])

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[120], line 2
      1 # Lists can't be added to sets as they are mutable
----> 2 s.add([1, 2])

TypeError: unhashable type: 'list'
In [121]:
# However, tuples can be added
s.add((1, 2))
s
Out[121]:
{(1, 2), 1, 2, 3, 4, 'hello'}

For immutable sets, you can use frozenset.

In [122]:
s2 = frozenset(s)
print(type(s2))
s2.add(5)

<class 'frozenset'>

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[122], line 3
      1 s2 = frozenset(s)
      2 print(type(s2))
----> 3 s2.add(5)

AttributeError: 'frozenset' object has no attribute 'add'

Sets have useful functions such as union, intersection and other set operations.

In [123]:
s
Out[123]:
{(1, 2), 1, 2, 3, 4, 'hello'}
In [124]:
s.intersection({1, 3, 4})
Out[124]:
{1, 3, 4}
In [125]:
{1, 2}.union({3, 4})
Out[125]:
{1, 2, 3, 4}

Expressions, Execution Logic, Ordering and Conversions¶

Expressions represent calculations from operations among data. These can be arithmetical operations, logical operations, indexing and membership. In terms of priority (precedence), they are ordered in the following manner:

indexing ([]) -> exponentiation (**) -> multiplication / division based operators (*, /, //, %) -> addition / subtraction (+, -) -> logical comparison (>, <=, etc.) and membership (in, not in) -> other logical operators (not > and > or)

Of course, to avoid confusion, don't forget to use parenthesis wherever necessary.

In [126]:
2 + 5 * 7
Out[126]:
37
In [127]:
(2 + 5) * 7
Out[127]:
49

When dealing with logical and and or, Python will take shortcuts instead of evaluating everything directly.

Consider the following examples:

In [128]:
# Python will throw an error when you divide an int or float by zero.
5 / 0

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Cell In[128], line 2
      1 # Python will throw an error when you divide an int or float by zero.
----> 2 5 / 0

ZeroDivisionError: division by zero
In [129]:
# Normally, you would expect an error to be thrown here as well:
True or 5 / 0
Out[129]:
True

In the example above, since True or X will have the boolean value of True for any Boolean value of X, the result will be True without evaluating the value of X. Same for the example below:

In [130]:
False and 5 /0
Out[130]:
False

When the result is not clear from the first operand, then the second operand will also be evaluated:

In [131]:
True and 5/ 0

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Cell In[131], line 1
----> 1 True and 5/ 0

ZeroDivisionError: division by zero

However, Python evaluates such expressions from left-to-right. The following expression, even if it would be trivially True given that X or True is always True, will evaluate the first operand and then throw an error:

In [132]:
# Always True?
(5/0) or True

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Cell In[132], line 2
      1 # Always True?
----> 2 (5/0) or True

ZeroDivisionError: division by zero

Type conversion¶

When applying a binary operator, Python will attempt to implicitly convert one data type to another if they are different types.

In [133]:
a = 5
type(a)
Out[133]:
int
In [134]:
b = 5.2
type(b)
Out[134]:
float
In [135]:
print(a+b)
type(a+b)

10.2
Out[135]:
float
In [136]:
c = 5 +4j
type(c)
Out[136]:
complex
In [137]:
print(c+a)
type(c+a)

(10+4j)
Out[137]:
complex

In the case of boolean values:

When implicitly converting a bool to a number, True will be converted to 1 and False will be converted to 0.

When implicitly converting a number to bool, 0 will be converted to False, and any non-zero number will be converted to 1.

In [138]:
True + 4
Out[138]:
5
In [139]:
True + False
Out[139]:
1
In [140]:
bool(5)
Out[140]:
True

Python supports multiple assignment, and you can also swap values of variables in place without having to use a third temporary variable.

In [141]:
a, b, c = 10, 20, 30
a, b, c
Out[141]:
(10, 20, 30)
In [142]:
# This is also possible
l = [8, 9]
a, b = l
a, b
Out[142]:
(8, 9)
In [143]:
# Swapping values
a,b = b,a
a, b
Out[143]:
(9, 8)
In [144]:
# Using a third variable:
print(a, b)
tmp = a
a = b
b = tmp
print(a, b)

9 8
8 9