Python - data types¶

A set of reference materials to help you in those occassional bouts of forgetfulness.

Python tutorials and references¶

Following are some resources to learn Python

1. Article with reviews about various tutorials http://noeticforce.com/best-free-tutorials-to-learn-python-pdfs-ebooks-online-interactive
2. user voted list of tutorials on quora: https://www.quora.com/What-is-the-best-online-resource-to-learn-Python
3. Google's Python class https://developers.google.com/edu/python/
4. https://www.learnpython.org/
5. Python reference documentation https://docs.python.org/3/
6. A list of Python libraries for various applications: https://github.com/vinta/awesome-python

Python type system¶

Before we get into data structures, let us talk about the type system in Python. At a high level, there are "Numbers", "Collections", "Callables" and "Singletons"

Numbers have two categories - Integral and Non-integral numbers.

• Integral number types:
  • Integers
  • Booleans
• Non integral number types:
  • Floats implemented as doubles in C
  • Complex
  • Decimals
  • Fractions

Collections have three sub categories:

• Sequence types
  • List (mutable)
  • Tuple (immutable)
  • String (immutable)
• Sets
  • Set - mutable
  • FrozenSet - immutable
• Mappings
  • Dict

Callables are types that can be called for execution

• UDF or user defined functions
• generators
• classes
• instance methods

Singletons are types that have only 1 instance within the execution space

• None
• NotImplemented
• Ellipsis operator : (...)

Python naming conventions¶

Variable / identifier names¶

The following rules apply when choosing variable names

• Can start with _, a-z, A-z
• Can be of any length and contain 0-9 in addition
• Can contain any unicode char
• Cannot be a reserved keyword in the Python language

Special names

• Vars that start with _ mean they are internal and not to be used by the consumer. They are private. But this is only by convention as everything is public in Python
• Further, when you run from module import *, vars that begin with _ are not imported by the interpreter
• Vars that follow __var_name__ are really reserved for Python internals. For example __init__ is used for a class constructor. The __lt__() method is used to implement a custom < operator etc. Don't invent your own __var__ names.
• Vars that follow __var_name are slightly different. They are used in a specific feature called name mangling in inheritance chains.

PEP8 conventions¶

The list below are just conventions and not rules. Following these will improve code readability.

• Packages : short, all-lowercase names. No underscores
• Modules: short, all-lowercase names. Can have underscores
• Classes: CapWords or upper-camel case
• Functions & Variables: snake_case
• Constants: UPPER_SNAKE_CASE

Data structures¶

Lists¶

l1 = list()
l2 = [] #both empty lists
l3 = [1,2,3]

In [1]:

l1 = list()
type(l1)

l1 = list() type(l1)

Out[1]:

list

In [2]:

l2 = []
len(l2)

l2 = [] len(l2)

Out[2]:

0

list slicing¶

In [3]:

l3 = [1,2,3,4,5,6,7,8,9]
l3[:] #prints all

l3 = [1,2,3,4,5,6,7,8,9] l3[:] #prints all

Out[3]:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

In [4]:

l3[0]

l3[0]

Out[4]:

1

In [5]:

l3[:4] #prints first 4. the : is slicing operator

l3[:4] #prints first 4. the : is slicing operator

Out[5]:

[1, 2, 3, 4]

In [6]:

l3[4:7] #upto 1 less than highest index

l3[4:7] #upto 1 less than highest index

Out[6]:

[5, 6, 7]

In [7]:

a = len(l3)
l3[a-1] #negative index for traversing in opposite dir

a = len(l3) l3[a-1] #negative index for traversing in opposite dir

Out[7]:

9

In [8]:

l3[-4:] #to pick the last 4 elements

l3[-4:] #to pick the last 4 elements

Out[8]:

[6, 7, 8, 9]

In [9]:

l3.reverse() #happens inplace

l3.reverse() #happens inplace

In [10]:

l3

l3

Out[10]:

[9, 8, 7, 6, 5, 4, 3, 2, 1]

append and extend¶

In [11]:

l3.append(10) #to add new values
l3

l3.append(10) #to add new values l3

Out[11]:

[9, 8, 7, 6, 5, 4, 3, 2, 1, 10]

In [12]:

a1 = ['a','b','c']
l3.append(a1)

a1 = ['a','b','c'] l3.append(a1)

In [13]:

l3[-1]

l3[-1]

Out[13]:

['a', 'b', 'c']

In [14]:

a1 = ['a','b','c']
l3.extend(a1) #to splice two lists. need not be same data type
l3

a1 = ['a','b','c'] l3.extend(a1) #to splice two lists. need not be same data type l3

Out[14]:

[9, 8, 7, 6, 5, 4, 3, 2, 1, 10, ['a', 'b', 'c'], 'a', 'b', 'c']

In [15]:

lol = [[1,2,3],[4,5,6]] #lol - list of lists
len(lol)

lol = [[1,2,3],[4,5,6]] #lol - list of lists len(lol)

Out[15]:

2

In [16]:

lol[1].reverse()
lol[1]

lol[1].reverse() lol[1]

Out[16]:

[6, 5, 4]

mutability of lists¶

list elements are mutable and can be changed

In [17]:

l3

l3

Out[17]:

[9, 8, 7, 6, 5, 4, 3, 2, 1, 10, ['a', 'b', 'c'], 'a', 'b', 'c']

In [18]:

l3[-1] = 'solar fare' #modify the last element
l3

l3[-1] = 'solar fare' #modify the last element l3

Out[18]:

[9, 8, 7, 6, 5, 4, 3, 2, 1, 10, ['a', 'b', 'c'], 'a', 'b', 'solar fare']

In [19]:

#list.insert(index, object) to insert a new value
print(str(len(l3))) #before insertion
l3.insert(1,'two')
l3

#list.insert(index, object) to insert a new value print(str(len(l3))) #before insertion l3.insert(1,'two') l3

14

Out[19]:

[9, 'two', 8, 7, 6, 5, 4, 3, 2, 1, 10, ['a', 'b', 'c'], 'a', 'b', 'solar fare']

In [20]:

# l3.pop(index) remove item at index and give that item
l3.pop(-3) #remove 3rd item from last and give them

# l3.pop(index) remove item at index and give that item l3.pop(-3) #remove 3rd item from last and give them

Out[20]:

'a'

In [21]:

l3

l3

Out[21]:

[9, 'two', 8, 7, 6, 5, 4, 3, 2, 1, 10, ['a', 'b', 'c'], 'b', 'solar fare']

In [22]:

# l3.clear()  to empty a list
lol.clear()
lol

# l3.clear() to empty a list lol.clear() lol

Out[22]:

[]

In [1]:

l3 = [9, 8, 7, 6, 5, 4, 3, 2, 1, 10, ['a', 'b', 'c'], 'a', 'b', 'c', 10,10,10]
l3

l3 = [9, 8, 7, 6, 5, 4, 3, 2, 1, 10, ['a', 'b', 'c'], 'a', 'b', 'c', 10,10,10] l3

Out[1]:

[9, 8, 7, 6, 5, 4, 3, 2, 1, 10, ['a', 'b', 'c'], 'a', 'b', 'c', 10, 10, 10]

In [2]:

# l3.count(value) counts the number of occurrences of a value
l3.count(10)

# l3.count(value) counts the number of occurrences of a value l3.count(10)

Out[2]:

4

Lists and indices¶

In [3]:

# l3.index(value, <start, <stop>>) returns the first occurrence of element
l3.index(10)

# l3.index(value, >) returns the first occurrence of element l3.index(10)

Out[3]:

9

Find all the indices of an element

In [5]:

# indices = [i for i, x in enumerate(my_list) if x == "whatever"]

#find all occurrence of 10
indices_of_10 = [i for i, x in enumerate(l3) if x == 10]
indices_of_10

# indices = [i for i, x in enumerate(my_list) if x == "whatever"] #find all occurrence of 10 indices_of_10 = [i for i, x in enumerate(l3) if x == 10] indices_of_10

Out[5]:

[9, 14, 15, 16]

In [7]:

list(enumerate(l3))

list(enumerate(l3))

Out[7]:

[(0, 9),
 (1, 8),
 (2, 7),
 (3, 6),
 (4, 5),
 (5, 4),
 (6, 3),
 (7, 2),
 (8, 1),
 (9, 10),
 (10, ['a', 'b', 'c']),
 (11, 'a'),
 (12, 'b'),
 (13, 'c'),
 (14, 10),
 (15, 10),
 (16, 10)]

Dictionaries¶

Key value pairs

d1 = dict()
d2 = {'key1':value,
      'key2':value2}

In [26]:

d1 = dict()
d2 = {}
len(d2)

d1 = dict() d2 = {} len(d2)

Out[26]:

0

In [27]:

d3 = {'day':'Thursday',
     'day_of_week':5,
     'start_of_week':'Sunday',
     'day_of_year':123,
     'dod':{'month_of_year':'Feb',
           'year':2017},
     'list1':[8,7,66]}
len(d3)

d3 = {'day':'Thursday', 'day_of_week':5, 'start_of_week':'Sunday', 'day_of_year':123, 'dod':{'month_of_year':'Feb', 'year':2017}, 'list1':[8,7,66]} len(d3)

Out[27]:

6

In [28]:

d3.keys()

d3.keys()

Out[28]:

dict_keys(['day', 'day_of_week', 'start_of_week', 'day_of_year', 'dod', 'list1'])

In [29]:

d3['start_of_week']

d3['start_of_week']

Out[29]:

'Sunday'

In [30]:

type(d3['dod'])

type(d3['dod'])

Out[30]:

dict

In [31]:

# now that dod is a dict, get its keys
d3['dod'].keys()

# now that dod is a dict, get its keys d3['dod'].keys()

Out[31]:

dict_keys(['month_of_year', 'year'])

In [32]:

d3['dod']['year']

d3['dod']['year']

Out[32]:

2017

mutability of dicts¶

dicts like lists are mutable

In [33]:

d3['day_of_year'] = -48
d3

d3['day_of_year'] = -48 d3

Out[33]:

{'day': 'Thursday',
 'day_of_week': 5,
 'day_of_year': -48,
 'dod': {'month_of_year': 'Feb', 'year': 2017},
 'list1': [8, 7, 66],
 'start_of_week': 'Sunday'}

In [46]:

# insert new values just by adding kvp (key value pair)
d3['workout_of_the_week']='bungee jumpging'
d3

# insert new values just by adding kvp (key value pair) d3['workout_of_the_week']='bungee jumpging' d3

Out[46]:

{'day': 'Thursday',
 'day_of_week': 5,
 'day_of_year': -48,
 'dod': {'month_of_year': 'Feb', 'year': 2017},
 'list1': [8, 7, 66],
 'start_of_week': 'Sunday',
 'workout_of_the_week': 'bungee jumpging'}

dict exploration¶

what happens when you inquire a key thats not present

In [47]:

d3['dayyy']

d3['dayyy']

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-47-c500fcefcb1b> in <module>()
----> 1 d3['dayyy']

KeyError: 'dayyy'

In [48]:

# safe way to get elements is to use get()
d3.get('day')

# safe way to get elements is to use get() d3.get('day')

Out[48]:

'Thursday'

In [49]:

d3.get('dayyy') #retuns None

d3.get('dayyy') #retuns None

In [50]:

# use items() to get a list of tuples of key value pairs
d3.items()

# use items() to get a list of tuples of key value pairs d3.items()

Out[50]:

dict_items([('day_of_week', 5), ('day', 'Thursday'), ('workout_of_the_week', 'bungee jumpging'), ('dod', {'year': 2017, 'month_of_year': 'Feb'}), ('list1', [8, 7, 66]), ('day_of_year', -48), ('start_of_week', 'Sunday')])

In [51]:

# use values() to get only the values
d3.values()

# use values() to get only the values d3.values()

Out[51]:

dict_values([5, 'Thursday', 'bungee jumpging', {'year': 2017, 'month_of_year': 'Feb'}, [8, 7, 66], -48, 'Sunday'])

Tuple¶

tuple is a immutable list

In [58]:

t1 = tuple()
t2 = ()
len(t1)

t1 = tuple() t2 = () len(t1)

Out[58]:

0

In [59]:

type(t2)

type(t2)

Out[59]:

tuple

In [60]:

t3 = (3,4,5,'t','g','b')
t3[0]

t3 = (3,4,5,'t','g','b') t3[0]

Out[60]:

3

In [61]:

#use it just like a list
t3[-1]

#use it just like a list t3[-1]

Out[61]:

'b'

mutability of tuples¶

cannot modify tuples.

In [62]:

t3[0] = 'good evening'

t3[0] = 'good evening'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-62-8d3766e24208> in <module>()
----> 1 t3[0] = 'good evening'

TypeError: 'tuple' object does not support item assignment

Sets¶

set is a sequence of unique values

s1 = set(<sequence>)
s2 = {}

In [63]:

s1 = set([1,1,1,2,2,2,4,4,4,4,4,4,4,5])
s1

s1 = set([1,1,1,2,2,2,4,4,4,4,4,4,4,5]) s1

Out[63]:

{1, 2, 4, 5}

In [64]:

s2 = {1,2,2,2,2,3} 
s2

s2 = {1,2,2,2,2,3} s2

Out[64]:

{1, 2, 3}

set from dictionary¶

Works on dicts too. But will return a set of keys only, not values.

In [65]:

# works on dicts too
s3_repeat_values = set({'k1':'v1',
                   'k2':'v1',
                   'k3':'v2'})
s3_repeat_values

# works on dicts too s3_repeat_values = set({'k1':'v1', 'k2':'v1', 'k3':'v2'}) s3_repeat_values

Out[65]:

{'k1', 'k2', 'k3'}

In [66]:

type(s3_repeat_values)

type(s3_repeat_values)

Out[66]:

set

In [67]:

# repeating keys
s3_repeat_keys = set({'k1':'v1',
                     'k1':'v2'})

# repeating keys s3_repeat_keys = set({'k1':'v1', 'k1':'v2'})

In [68]:

s3_repeat_keys

s3_repeat_keys

Out[68]:

{'k1'}

Note. When you create a dict with duplicate keys, Python just keeps the last occurrence of the kvp. It thinks the kvp needs to be updated to the latest value

In [69]:

d80 = {'k1':'v1', 'k2':'v2', 'k1':'v45'} # k1 is repeated
d80

d80 = {'k1':'v1', 'k2':'v2', 'k1':'v45'} # k1 is repeated d80

Out[69]:

{'k1': 'v45', 'k2': 'v2'}