
N={1,3,4,5,7,8}
print('The sum of ∑_i∈N i*i =',sum( i**2 for i in N ) )

The sum of ∑_i∈N i*i = 164


1 + 2 * 3

7


help("topics")

Here is a list of available topics.  Enter any topic name to get more help.

ASSERTION           DELETION            LOOPING             SHIFTING
ASSIGNMENT          DICTIONARIES        MAPPINGMETHODS      SLICINGS
ATTRIBUTEMETHODS    DICTIONARYLITERALS  MAPPINGS            SPECIALATTRIBUTES
ATTRIBUTES          DYNAMICFEATURES     METHODS             SPECIALIDENTIFIERS
AUGMENTEDASSIGNMENT ELLIPSIS            MODULES             SPECIALMETHODS
BASICMETHODS        EXCEPTIONS          NAMESPACES          STRINGMETHODS
BINARY              EXECUTION           NONE                STRINGS
BITWISE             EXPRESSIONS         NUMBERMETHODS       SUBSCRIPTS
BOOLEAN             FLOAT               NUMBERS             TRACEBACKS
CALLABLEMETHODS     FORMATTING          OBJECTS             TRUTHVALUE
CALLS               FRAMEOBJECTS        OPERATORS           TUPLELITERALS
CLASSES             FRAMES              PACKAGES            TUPLES
CODEOBJECTS         FUNCTIONS           POWER               TYPEOBJECTS
COMPARISON          IDENTIFIERS         PRECEDENCE          TYPES
COMPLEX             IMPORTING           PRIVATENAMES        UNARY
CONDITIONAL         INTEGER             RETURNING           UNICODE
CONTEXTMANAGERS     LISTLITERALS        SCOPING             
CONVERSIONS         LISTS               SEQUENCEMETHODS     
DEBUGGING           LITERALS            SEQUENCES


def factorial(n):
    """returns n!"""
    return 1 if n < 2 else n * factorial(n-1)

factorial.__doc__

'returns n!'


x = 2          # anything after a '#' is a comment
y = 5
xy = 'Hey'
print(x+y, xy) # not really necessary as the last value in a bit of code is displayed by default

7 Hey


first_number = 10
second_number = 5

[first_number + second_number, 10 + 5]

[15, 15]


first_number = float(10)


my_number = 5
my_number = 10
print(my_number)

10


x = y = 1
print(x,y)

1 1


my_var = 2
[type(my_var), type(2), isinstance(my_var, int)]

[int, int, True]


complex(1,2)
(1.0+2j) # the same number as above

(1+2j)


def donothing():
    b = 0

print(donothing())

None


a = 1
a = None
print(a)

None


'This is a string'

'This is a string'


"It's another string"

"It's another string"


"""Triple quotes (also with '''), allow strings to break over multiple lines.
Alternatively \n is a newline character (\t for tab, \\ is a single backslash)"""

"Triple quotes (also with '''), allow strings to break over multiple lines.\nAlternatively \n is a newline character (\t for tab, \\ is a single backslash)"


"Hello World! " * 5

'Hello World! Hello World! Hello World! Hello World! Hello World! '


"Hello" + "World"

'HelloWorld'


1+2.0

3.0

3-1

2


2 * (3+0j) * 1.0

(6+0j)


[3/4, 4/2]

[0.75, 2.0]


11**300

2617010996188399907017032528972038342491649416953000260240805955827972056685382434497090341496787032585738884786745286700473999847280664191731008874811751310888591786111994678208920175143911761181424495660877950654145066969036252669735483098936884016471326487403792787648506879212630637101259246005701084327338001


15%10

5


1//2

0


8 // 3

2


x = 2
y = 3
z = x + y / 2
print(f'The mean of x and y is {z}')

The mean of x and y is 3.5


x = 1
x += 2 # add 2 to x
print("x is",x)
x <<= 2 # left shift by 2 (equivalent to x *= 4)
print('x is',x)
x **= 2 # x := x^2
print('x is',x)

x is 3
x is 12
x is 144


z = 2
z == 2

True


'a'<'A'

False


[1,2]<[1,2,3]

True


0.5 < z <= 1

False


a = 2 #binary: 10
b = 3 #binary: 11
print('a & b =',a & b,"=",bin(a&b))
print('a | b =',a | b,"=",bin(a|b))
print('a ^ b =',a ^ b,"=",bin(a^b))
print('b << a =',b<<a,"=",bin(b<<a))

a & b = 2 = 0b10
a | b = 3 = 0b11
a ^ b = 1 = 0b1
b << a = 12 = 0b1100


print( not (True and False), "==", not True or not False)

True == True


num = 1
num_two = num
num == num_two

True


[id(num), id(num_two)]

[140716920481568, 140716920481568]


num is num_two

True


num = 1
bool = True
[num == bool, num is bool]

[True, False]


'Program' in 'Programming'

True


'sausage' not in ['spam', 'ham', 'egg']

True


hex(171) # hexadecmial value as string

'0xab'


0xAB

171


print(int(7.7), int('111',2),int('7'))

7 7 7


print(str(True),str(1.2345678),str(-2))

True 1.2345678 -2


import math
math.sin(math.pi/2)
from math import * # avoid having to put a math. in front of every mathematical function
sin(pi/2) # equivalent to the statement above

1.0


print( round(5.6231) )
print( round(4.55892, 2) )

6
4.56


c =complex('5+2j')
print("|5+2i| =", abs(c) , "\t |-5| =", abs(-5) )

|5+2i| = 5.385164807134504 	 |-5| = 5


divmod(9,2)

(4, 1)


abc =  input("abc = ")
abcValue=eval(abc)
print(abc,'=',abcValue)

abc = 42
42 = 42


print("Hello","World")

Hello World


print("Hello","World",sep='...',end='!!',flush=True)

Hello...World!!


string1='World'
string2='!'
print('Hello' + " " + string1 + string2)

Hello World!


print("Hello %s" % string1)
print("Actual Number = %d" %18)
print("Float of the number = %f" %18)
print("Octal equivalent of the number = %o" %18)
print("Hexadecimal equivalent of the number = %x" %18)
print("Exponential equivalent of the number = %e" %18)

Hello World
Actual Number = 18
Float of the number = 18.000000
Octal equivalent of the number = 22
Hexadecimal equivalent of the number = 12
Exponential equivalent of the number = 1.800000e+01


print("Hello %s %s. This meaning of life is %d" %(string1,string2,42))

Hello World !. This meaning of life is 42


print('Print width 10: |%10s|'%'x')
print('Print width 10: |%-10s|'%'x') # left justified
print("The number pi = %.2f to 2 decimal places"%3.1415)
print("More space pi = %10.2f"%3.1415)
print("Pad pi with 0 = %010.2f"%3.1415) # pad with zeros

Print width 10: |         x|
Print width 10: |x         |
The number pi = 3.14 to 2 decimal places
More space pi =       3.14
Pad pi with 0 = 0000003.14


name = "Peppa Pig"
age = 42
# The Modern way of formatting a string
print(f"Hello {name}, you are {age} years old")

Hello Peppa Pig, you are 42 years old


s="heLLo wORLd!"
print(s.capitalize(),"vs",s.title())
print("upper: '%s'"%s.upper(),"lower: '%s'"%s.lower(),"and swapped: '%s'"%s.swapcase())
print('|%s|' % "Hello World".center(30)) # center in 30 characters
print('|%s|'% "     lots of space             ".strip()) # remove leading and trailing whitespace
print('%s without leading/trailing d,h,L or ! = |%s|',s.strip("dhL!"))
print("Hello World".replace("World","Class"))

Hello world! vs Hello World!
upper: 'HELLO WORLD!' lower: 'hello world!' and swapped: 'HEllO WorlD!'
|         Hello World          |
|lots of space|
%s without leading/trailing d,h,L or ! = |%s| eLLo wOR
Hello Class


s="Hello World"
print("The length of '%s' is"%s,len(s),"characters") # len() gives length
s.startswith("Hello") and s.endswith("World") # check start/end
# count strings
print("There are %d 'l's but only %d World in %s" % (s.count('l'),s.count('World'),s))
print('"el" is at index',s.find('el'),"in",s) #index from 0 or -1

The length of 'Hello World' is 11 characters
There are 3 'l's but only 1 World in Hello World
"el" is at index 1 in Hello World


'abc' < 'bbc' <= 'bbc'

True


"ABC" in "This is the ABC of Python"

True


s = '123456789'
print("The string '%s' string is %d characters long" % (s, len(s)) )
print('First character of',s,'is',s[0])
print('Last character of',s,'is',s[len(s)-1])

The string '123456789' string is 9 characters long
First character of 123456789 is 1
Last character of 123456789 is 9


print('First character of',s,'is',s[-len(s)])
print('Last character of',s,'is',s[-1])

First character of 123456789 is 1
Last character of 123456789 is 9


print("First three characters",s[0:3])
print("Next three characters",s[3:6])

First three characters 123
Next three characters 456


print("First three characters", s[:3])
print("Last three characters", s[-3:])

First three characters 123
Last three characters 789


s = "one -> two  ->  three"
print( s.partition("->") )
print( s.split() )
print( s.split(" -> ") )
print( ";".join( s.split(" -> ") ) )

('one ', '->', ' two  ->  three')
['one', '->', 'two', '->', 'three']
['one', 'two ', ' three']
one;two ; three


s='012345'
sX=s[:2]+'X'+s[3:] # this creates a new string with 2 replaced by X
print("creating new string",sX,"OK")
sX=s.replace('2','X') # the same thing
print(sX,"still OK")

creating new string 01X345 OK
01X345 still OK


x = 12
if x > 10:
    print("Hello")

Hello


x = 12
if 10 < x < 11:
    print("hello")
else:
    print("world")

world


x = 10
y = 12
if x > y:
    print("x>y")
elif x < y:
    print("x<y")
else:
    print("x=y")

x<y


exit_program = True
manual_override = False
critical_systems_shutdown = False

if not exit_program and not critical_systems_shutdown:
    if manual_override:
        print("Shutting system down manually")
    else:
        print("This program will not exit just yet")
elif exit_program and critical_systems_shutdown is not True:
    print("Critical systems must be safely shut down before exiting the program")
else:
    print("This program will now be terminated...")

Critical systems must be safely shut down before exiting the program


my_boolean = False
my_string = "Hello" if my_boolean else "World"
print(my_string)

World


languages = ["HTML", "CSS", "JavaScript"]
for language in languages:
    print(language)

HTML
CSS
JavaScript


for character in "Python":
    print(character)

P
y
t
h
o
n


total=0
for i,j in [(1,2),(3,1)]:
    total += i**j
print("total =",total)

total = 4


list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for list1 in list_of_lists:
        print(list1)

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


list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
total=0
for list1 in list_of_lists:
    for x in list1:
        total = total+x
print(total)

45


print("reversed: \t",end="")
for ch in reversed("abc"):
    print(ch,end=";")

reversed: 	c;b;a;


print("enuemerated:\t",end="")
for i,ch in enumerate("abc"):
    print(i,"=",ch,end="; ")

enuemerated:	0 = a; 1 = b; 2 = c;


print("zip'ed: ")
for a,x in zip("abc","xyz"):
    print(a,":",x)

zip'ed: 
a : x
b : y
c : z


foods = ['bacon', 'sausage', 'egg', 'spam']
for ind in range(len(foods)):
    # In this example only the index is iterated over not the value
    print(ind, foods[ind])

0 bacon
1 sausage
2 egg
3 spam


# Return integers from 1 through 5
for i in range(1,5,1):
    print(i, end='')

1234


countdown_number = 3

print("Initiating Countdown Sequence...")
print("Lift Off Will Commence In...")

while countdown_number >= 0:
    print(f"{countdown_number} seconds...")
    countdown_number -= 1

print("And We Have Lift Off!")

Initiating Countdown Sequence...
Lift Off Will Commence In...
3 seconds...
2 seconds...
1 seconds...
0 seconds...
And We Have Lift Off!


for number in range(5):
    if number == 3:
        break    # break here
    print(f'Number is  {number}')
print('Left the loop')

Number is  0
Number is  1
Number is  2
Left the loop


for number in range(5):
    if number == 3:
        continue    # skip 3
    print(f'Number is  {number}')
print('Left the loop')

Number is  0
Number is  1
Number is  2
Number is  4
Left the loop


for number in range(5):
    if number == 3:
        pass    # disregard the if case
    print(f'Number is  {number}')
print('Left the loop')

Number is  0
Number is  1
Number is  2
Number is  3
Number is  4
Left the loop


count = 0
while count < 10:
    count += 1
    if count % 2 == 0: # even number
        count += 2
        continue
    elif 5 < count < 9:
        break # abnormal exit if we get here!
    print("count =",count)
else: # while-else
    print("Normal exit with",count)

count = 1
count = 5
count = 9
Normal exit with 12


for i in range(1,12):
    printed = False
    if not i%2:
        print('Fizz', end="")
        printed = True
    if not i%3:
        print('Buzz', end="")
        printed = True
    print("" if printed else i)

1
Fizz
Buzz
Fizz
5
FizzBuzz
7
Fizz
Buzz
Fizz
11


i = 2
while i < 10:
    j = 2
    while j <= i/j:
        if not i % j:
            break
        j += 1
    else:
        print(f'{i} is a prime number')
    i += 1

2 is a prime number
3 is a prime number
5 is a prime number
7 is a prime number


a = []
type(a)

list


fruits = ['apple', 'orange', 'banana', 'pear', 'plum']
# Print all fruits
for fruit in fruits:
    print(fruit)

apple
orange
banana
pear
plum


# Get an item located in a list
second_item = fruits[1]
print(second_item)

orange


# Add an item to the list
fruits.append('cherries')
print(fruits)

['apple', 'orange', 'banana', 'pear', 'plum', 'cherries']


# Reverse the list
fruits.reverse()
print(fruits)

['cherries', 'plum', 'pear', 'banana', 'orange', 'apple']


# Sort the list alphabetically (inplace):
fruits.sort()
print(fruits)

['apple', 'banana', 'cherries', 'orange', 'pear', 'plum']


[fruits[0], fruits[5]]

['apple', 'plum']


[fruits[-1], fruits[-5]]

['plum', 'banana']


[fruits[0], fruits[-6]]

['apple', 'apple']


vegetables = ['carrot','potato','leek','onion','spinach']
z  = [fruits, vegetables]
print( z )

[['apple', 'banana', 'cherries', 'orange', 'pear', 'plum'], ['carrot', 'potato', 'leek', 'onion', 'spinach']]


print(z[0][1])

banana


["this is a valid list",2,3.6,(1+2j),["a","sublist"]]

['this is a valid list', 2, 3.6, (1+2j), ['a', 'sublist']]


fruits = ["apple", "banana", "peach", "pear", "plum", "orange"]
x = slice(1, 4, 2)
fruits[x]

['banana', 'pear']


fruits[1:4:2]

['banana', 'pear']


fruits[:2]

['apple', 'banana']


fruits[:]

['apple', 'banana', 'peach', 'pear', 'plum', 'orange']


fruits[::-1]

['orange', 'plum', 'pear', 'peach', 'banana', 'apple']


lst1=['a','b','c','b']
lst2=['d','e']
lst1.append(lst2)
lst1

['a', 'b', 'c', 'b', ['d', 'e']]


lst1=['a','b','c','b']
lst1.extend(lst2)
lst1

['a', 'b', 'c', 'b', 'd', 'e']


['a','b','c','b'] + ['Z']

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


lst1[2] = 'Python'
lst1

['a', 'b', 'Python', 'b', 'd', 'e']


lst1.insert(2, 'JavaScript')
lst1

['a', 'b', 'JavaScript', 'Python', 'b', 'd', 'e']


lst1.remove('JavaScript')
lst1

['a', 'b', 'Python', 'b', 'd', 'e']


del lst1[2]
lst1

['a', 'b', 'b', 'd', 'e']


['a', 'b', 'c', 'b'].count('b')

2


lst1.index('b')

1


lst1=['a', 'b', 'c', 'b']
lst1.pop()

'b'


lst1

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


lst1.pop(1)

'b'


lst1

['a', 'c']


lst1.reverse()
lst1

['c', 'a']


lst1.sort()
print(lst1)

['a', 'c']


lst2=sorted([3,2,1]) # another way to sort
lst2

[1, 2, 3]


lst2=sorted([3,1,2],reverse=True)
lst2 # remember that `sorted` creates a copy of the list in sorted order

[3, 2, 1]


menu = ['eggs', 'bacon', 'spam', 'ham']
menu.sort()
menu

['bacon', 'eggs', 'ham', 'spam']


menu.sort(reverse=True)
menu

['spam', 'ham', 'eggs', 'bacon']


menu.sort(key=len)
menu

['ham', 'spam', 'eggs', 'bacon']


len(menu)

4


nums=[2,3,4,5]
print("min =",min(nums),"  max =",max(nums),"  total =",sum(nums))

min = 2   max = 5   total = 14


[1,2,3] + [5,4,7]

[1, 2, 3, 5, 4, 7]


names = ['Earth','Air','Fire','Water']


'Fire' in names

True


'Metal' in names

False


mlist = ['bzaa','ds','nc','az','z','klm']
print("max =",max(mlist))
print("min =",min(mlist))

max = z
min = az


nlist = ['5','24','93','1000']
print("max =",max(nlist))
print('min =',min(nlist))

max = 93
min = 1000


print('longest =',max(mlist, key=len))
print('shortest =',min(mlist, key=len))

longest = bzaa
shortest = z


list('hello world !')

['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', ' ', '!']


'Hello   World !!'.split()

['Hello', 'World', '!!']


lista= [2,1,4,3]
listb = lista
print(listb)

[2, 1, 4, 3]


lista.sort()
lista.pop()
lista.append(9)
print("A =",lista)
print("B =",listb)

A = [1, 2, 3, 9]
B = [1, 2, 3, 9]


lista = [2,1,4,3]
listb = lista[:] # make a copy by taking a slice from beginning to end
print("Starting with:")
print("A =",lista)
print("B =",listb)
lista.sort()
lista.pop()
lista.append(9)
print("Finnished with:")
print("A =",lista)
print("B =",listb)

Starting with:
A = [2, 1, 4, 3]
B = [2, 1, 4, 3]
Finnished with:
A = [1, 2, 3, 9]
B = [2, 1, 4, 3]


3 * ['a',1]

['a', 1, 'a', 1, 'a', 1]


['a',1] * 4

['a', 1, 'a', 1, 'a', 1, 'a', 1]


numbers = []
for x in range(10):
    numbers.append(x)
numbers

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


[x for x in range(10)]

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


combination = []
for x in [1,2,3]:
    for y in [3,1,4]:
        if x != y:
            combination.append((x,y))
combination

[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]


[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]

[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]


# every natural number
[i for i in range(10)]

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


# every second natural number
[i for i in range(0,11,2)]

[0, 2, 4, 6, 8, 10]


# squared numbers
[x**2 for x in range(0,8)]

[0, 1, 4, 9, 16, 25, 36, 49]


# list of Tupels of number pairs
[((i,(i+1))) for i in range(5)]

[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]


# repeat a string 7 times in a new list
['woohoo' for i in range(7)]

['woohoo', 'woohoo', 'woohoo', 'woohoo', 'woohoo', 'woohoo', 'woohoo']


# list of letters of a string
[i for i in 'hello world']

['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']


# generate list of Tuples
ab = 'ABCDEF'
[(ab[i],ab[j]) for i in range(0,3) for j in range(3,6)]

[('A', 'D'),
 ('A', 'E'),
 ('A', 'F'),
 ('B', 'D'),
 ('B', 'E'),
 ('B', 'F'),
 ('C', 'D'),
 ('C', 'E'),
 ('C', 'F')]


[i**2 for i in [1,2,3]]

[1, 4, 9]


[10*i+j for i in [1,2,3] for j in [5,7]]

[15, 17, 25, 27, 35, 37]


[10*i+j for i in [1,2,3] if i%2==1 for j in [4,5,7] if j >= i+4] # keep odd i and  j larger than i+3 only

[15, 17, 37]


matrix = [
    [11, 12, 13, 14],
    [15, 16, 17, 18],
    [19, 20, 21, 22],]
transposed = []
for i in range(4):
    transposed_row = []
    for row in matrix:
        transposed_row.append(row[i])
    transposed.append(transposed_row)
    print(transposed_row)

[11, 15, 19]
[12, 16, 20]
[13, 17, 21]
[14, 18, 22]


[[row[i] for row in matrix] for i in range(4)]

[[11, 15, 19], [12, 16, 20], [13, 17, 21], [14, 18, 22]]


1,2,3

(1, 2, 3)


() # empty, zero-length tuple

()


tuple() # also, empty, zero-length tuple

()

42,

(42,)


origin = (0.0,0.0,0.0)
x = origin
# x[1] = 1 # can't do something like this as it would change the origin
x = (1, 0, 0) # perfectly OK
print(x)
print(type(x))

(1, 0, 0)
<class 'tuple'>


2*(21,)

(21, 21)


tuple([1,2,3])

(1, 2, 3)


tuple('Hello')

('H', 'e', 'l', 'l', 'o')


(3,5,7)[2]

7


(3,5,7)[1:3]

(5, 7)


(a,b,c)= ('alpha','beta','gamma') # parentheses are optional
a,b,c= 'alpha','beta','gamma' # The same as the above
print(a,b,c)

alpha beta gamma


a,b,c = ['Alpha','Beta','Gamma'] # can assign lists
print(a,b,c)

Alpha Beta Gamma


[a,b,c]=('this','is','ok') # even this is OK
print(a,b,c)

this is ok


(w,(x,y),z)=(1,(2,3),4)
print(w,x,y,z)

1 2 3 4


(w,xy,z)=(1,(2,3),4)
print(w,xy,z) # notice that xy is now a tuple

1 (2, 3) 4


d=tuple('a string with many "a"s')
d.count('a')

3


d.index('a')

0


d = dict() # or equivalently d={}
print(type(d))
d['abc'] = 3
d[4] = "A string"
print(d)

<class 'dict'>
{'abc': 3, 4: 'A string'}


d = { 1: 'One', 2 : 'Two', 100 : 'Hundred'}
len(d)

3


print(d[1])

One


user = {
    "username": "tombombadil",
    "first_name": "Tom",
    "last_name": "Bombadil",
    "age": 100
}
print(user)
print(user['age'])

{'username': 'tombombadil', 'first_name': 'Tom', 'last_name': 'Bombadil', 'age': 100}
100


user['home'] = 'Withywindle, Middle-Earth'
user['age'] = 99
print(user)

{'username': 'tombombadil', 'first_name': 'Tom', 'last_name': 'Bombadil', 'age': 99, 'home': 'Withywindle, Middle-Earth'}


del user['home'] 
print(user)

{'username': 'tombombadil', 'first_name': 'Tom', 'last_name': 'Bombadil', 'age': 99}


print(list(user))
print(sorted(user))
print(user)

['username', 'first_name', 'last_name', 'age']
['age', 'first_name', 'last_name', 'username']
{'username': 'tombombadil', 'first_name': 'Tom', 'last_name': 'Bombadil', 'age': 99}


print('username' in user)

True


names = ['One', 'Two', 'Three', 'Four', 'Five']
numbers = [1, 2, 3, 4, 5]
[ (name,number) for name,number in zip(names,numbers)] # create (name,number) pairs

[('One', 1), ('Two', 2), ('Three', 3), ('Four', 4), ('Five', 5)]


a1 = dict((name,number) for name,number in zip(names,numbers))
print(a1)

{'One': 1, 'Two': 2, 'Three': 3, 'Four': 4, 'Five': 5}


matrix={ (0,1): 3.5, (2,17): 0.1}
matrix[2,2] = matrix[0,1] + matrix[2,17]
# matrix[2,2] is equivalent to matrix[ (2,2) ]
print(matrix)

{(0, 1): 3.5, (2, 17): 0.1, (2, 2): 3.6}


a2 = { name : len(name) for name in names}
print(a2)

{'One': 3, 'Two': 3, 'Three': 5, 'Four': 4, 'Five': 4}


keys = ['username', 'first_name', 'last_name', 'age']
default_value = ''
user = dict.fromkeys(keys, default_value)
print(user)

{'username': '', 'first_name': '', 'last_name': '', 'age': ''}


user['username'] = 'tombombadil'
user['first_name'] = 'Tom'
user['last_name'] = 'Bombadil'
user['age'] = 100
print(user)

{'username': 'tombombadil', 'first_name': 'Tom', 'last_name': 'Bombadil', 'age': 100}


print(user['age'])

100


print(user.get('home', "doesn't exist"))
user['home'] = 'Withywindle, Middle-Earth'
user['age'] = 99
print(user)

doesn't exist
{'username': 'tombombadil', 'first_name': 'Tom', 'last_name': 'Bombadil', 'age': 99, 'home': 'Withywindle, Middle-Earth'}


del user['home'] 
print(user)

{'username': 'tombombadil', 'first_name': 'Tom', 'last_name': 'Bombadil', 'age': 99}


print(list(user.keys()))
print(list(user.values()))
print(user.items())

['username', 'first_name', 'last_name', 'age']
['tombombadil', 'Tom', 'Bombadil', 99]
dict_items([('username', 'tombombadil'), ('first_name', 'Tom'), ('last_name', 'Bombadil'), ('age', 99)])


user = {
    "username": "tombombadil",
    "first_name": "Tom",
    "last_name": "Bombadil",
    "age": 100
}
print(user)
print(user.items())

{'username': 'tombombadil', 'first_name': 'Tom', 'last_name': 'Bombadil', 'age': 100}
dict_items([('username', 'tombombadil'), ('first_name', 'Tom'), ('last_name', 'Bombadil'), ('age', 100)])


print(user.get('age', 0))

100


user.update({'home': 'Withywindle, Middle-Earth'})
print(user)

{'username': 'tombombadil', 'first_name': 'Tom', 'last_name': 'Bombadil', 'age': 100, 'home': 'Withywindle, Middle-Earth'}


print(user.popitem())
print(user)

('home', 'Withywindle, Middle-Earth')
{'username': 'tombombadil', 'first_name': 'Tom', 'last_name': 'Bombadil', 'age': 100}


user.clear()
print(user)

{}


print("a1 has",len(a1),"elements")
print("One is in a1",'One' in a1,"but not 2:", 2 in a1) # 'in' checks keys only

a1 has 5 elements
One is in a1 True but not 2: False


a2.clear()
print(a2)

{}


[ v for v in a1.values() ]

[1, 2, 3, 4, 5]


{ k for k in a1.keys() }

{'Five', 'Four', 'One', 'Three', 'Two'}


",  ".join( "%s = %d" % (name,val) for name,val in a1.items())

'One = 1,  Two = 2,  Three = 3,  Four = 4,  Five = 5'


val = a1.pop('Four')
print(a1)
print("Removed",val)

{'One': 1, 'Two': 2, 'Three': 3, 'Five': 5}
Removed 4


user = {
    "username": "tombombadil",
    "first_name": "Tom",
    "last_name": "Bombadil",
    "age": 100
}

for key, value in user.items():
    print(f"Key: {key}")
    print(f"Value: {value}")
    print("------------------")

Key: username
Value: tombombadil
------------------
Key: first_name
Value: Tom
------------------
Key: last_name
Value: Bombadil
------------------
Key: age
Value: 100
------------------


squares = {}
for x in (2, 4, 6):
    squares[x] = x**2
squares

{2: 4, 4: 16, 6: 36}


{x: x**2 for x in (2, 4, 6)}

{2: 4, 4: 16, 6: 36}


{fruit:len(fruit) for fruit in ['apple', 'mango', 'banana','cherry']}

{'apple': 5, 'mango': 5, 'banana': 6, 'cherry': 6}


{i:(i*'*') for i in range(0,5)}

{0: '', 1: '*', 2: '**', 3: '***', 4: '****'}


{i:(True if i%2==0 else False) for i in range(10)}

{0: True,
 1: False,
 2: True,
 3: False,
 4: True,
 5: False,
 6: True,
 7: False,
 8: True,
 9: False}


{(i,j): (True if i==j else False) for i in range(4) for j in range(4)}

{(0, 0): True,
 (0, 1): False,
 (0, 2): False,
 (0, 3): False,
 (1, 0): False,
 (1, 1): True,
 (1, 2): False,
 (1, 3): False,
 (2, 0): False,
 (2, 1): False,
 (2, 2): True,
 (2, 3): False,
 (3, 0): False,
 (3, 1): False,
 (3, 2): False,
 (3, 3): True}


payroll = {'emp1': {'name': 'Precious', 'job': 'Mgr', 'Wage': 50000},
     'emp2': {'name': 'Kim', 'job': 'Dev', 'Wage': 60000},
     'emp3': {'name': 'Sam', 'job': 'Dev', 'Wage': 70000}}
print(payroll)

{'emp1': {'name': 'Precious', 'job': 'Mgr', 'Wage': 50000}, 'emp2': {'name': 'Kim', 'job': 'Dev', 'Wage': 60000}, 'emp3': {'name': 'Sam', 'job': 'Dev', 'Wage': 70000}}


print(payroll['emp1']['name'])
print(payroll['emp1'].get('salary'))
print(payroll['emp1'].get('Wage'))
payroll['emp4'] = {'name': 'Max', 'job': 'Admin', 'Wage': 30000}
print(payroll)
del payroll['emp3']

Precious
None
50000
{'emp1': {'name': 'Precious', 'job': 'Mgr', 'Wage': 50000}, 'emp2': {'name': 'Kim', 'job': 'Dev', 'Wage': 60000}, 'emp3': {'name': 'Sam', 'job': 'Dev', 'Wage': 70000}, 'emp4': {'name': 'Max', 'job': 'Admin', 'Wage': 30000}}


for id, info in payroll.items():
    print(f'Employee ID: {id}')
    for key in info:
        print(f'{key} : {info[key]}')
    print()

Employee ID: emp1
name : Precious
job : Mgr
Wage : 50000

Employee ID: emp2
name : Kim
job : Dev
Wage : 60000

Employee ID: emp4
name : Max
job : Admin
Wage : 30000


from timeit import timeit
bigList = [i for i in range(0,100000)]
bigSet = set(bigList)
# how long to find the last number out of 10,000 items?
timeit(lambda: 99999 in bigList, number=1000) # run command 1000 times

2.3167801000000168


timeit(lambda: 99999 in bigSet, number=1000) # run command 1000 times

0.0004320999999549713


breakfast = {'bacon', 'egg', 'spam', 'spam', 'spam', 'spam', 'spam'}
print(breakfast)
print('egg' in breakfast)
breakfast.add('sausage')
print(breakfast)
breakfast.update(['Lobster Thermidor', 'truffle pate', 'crevettes', 'shallots','aubergines'])
print(breakfast)
breakfast.discard('aubergines')
print(breakfast)

{'bacon', 'spam', 'egg'}
True
{'bacon', 'spam', 'sausage', 'egg'}
{'spam', 'egg', 'aubergines', 'sausage', 'shallots', 'bacon', 'truffle pate', 'Lobster Thermidor', 'crevettes'}
{'spam', 'egg', 'sausage', 'shallots', 'bacon', 'truffle pate', 'Lobster Thermidor', 'crevettes'}


set1 = set()
print(type(set1))

<class 'set'>


set0 = set([1,2,2,3,3,4])
set0 = {3,3,4,1,2,2} # equivalent to the above
print(set0) # order is not preserved

{1, 2, 3, 4}


type({})

dict


# Create a set
directions = set(['north', 'south', 'east', 'west'])
# Print its members
for direction in directions:
    print(direction)

# Add an item to the set:
directions.add('northwest')

print()
# Print the members again
# Notice the order cannot be relied upon!
for direction in directions:
    print(direction)

south
west
north
east

south
west
north
northwest
east


hello = set("Hello")
world = set("World")
print(f"The unique letters in hello are: {hello}")
print(f"The letters in hello or world or both are: {hello|world}") # | is the symbol for union
print(f"The letters in both hello and world are: {hello&world}") # & is the symbol for intersection
print(f"The letters in hello but not world are: {hello-world}") # - is the symbol for difference
print(f"The letters in hello and world but not both are: {hello^world}") # ^ is the symbol for symmetric difference

The unique letters in hello are: {'H', 'e', 'o', 'l'}
The letters in hello or world or both are: {'H', 'W', 'o', 'l', 'd', 'e', 'r'}
The letters in both hello and world are: {'o', 'l'}
The letters in hello but not world are: {'H', 'e'}
The letters in hello and world but not both are: {'H', 'W', 'd', 'e', 'r'}


set1 = set([1,2,3])


set2 = set([2,3,4,5])


set1.union(set2)

{1, 2, 3, 4, 5}


set1.add(0)
set1

{0, 1, 2, 3}


set1.intersection(set2)

{2, 3}


set1.difference(set2)

{0, 1}


set2.symmetric_difference(set1)

{0, 1, 4, 5}


print( set1.issubset(set2) )
print( set1.isdisjoint(set2) )
print( set1.issuperset(set2) )

False
False
False


set1.pop()
print(set1)

{1, 2, 3}


set1.remove(2)
set1

{1, 3}


set1.clear()
set1

set()


not "" and not set() and not [] and not {}

True


"" or [] # returns the last "False" value

[]


{1,2} or ""

{1, 2}


S = 'The Taj Mahal is beautiful'
print([x for x in S if x.islower()]) # list of lower case charactes
words=S.split() # list of words
print("Words are:",words)
print("--".join(words)) # hyphenated 
" ".join(w.capitalize() for w in words) # capitalise words

['h', 'e', 'a', 'j', 'a', 'h', 'a', 'l', 'i', 's', 'b', 'e', 'a', 'u', 't', 'i', 'f', 'u', 'l']
Words are: ['The', 'Taj', 'Mahal', 'is', 'beautiful']
The--Taj--Mahal--is--beautiful

'The Taj Mahal Is Beautiful'


print(S[4])
print(S[4:])

T
Taj Mahal is beautiful


print("Hello Jack.")
print("Jack, how are you?")

Hello Jack.
Jack, how are you?


def print_message():
    print("Hello Jack.")
    print("Jack, how are you?")
    
print_message() # execute the function

Hello Jack.
Jack, how are you?


def print_message(username):
    print("Hello %s." % username)
    print(username + ',' ,"how are you?")


name1 = 'Sally' # or use input('Please enter your name : ')


print_message(name1)

Hello Sally.
Sally, how are you?


def times(x,y):
    z = x*y
    return z
    z = 17 # this statement is never executed


c = times(4,5)
print(c)

20


def times(x,y):
    '''This multiplies the two input arguments'''
    return x*y


c = times(4,5)
print(c)

20


help(times)

Help on function times in module __main__:

times(x, y)
    This multiplies the two input arguments


eglist = [10,50,30,12,6,8,100]


def egfunc(eglist):
    highest = max(eglist)
    lowest = min(eglist)
    first = eglist[0]
    last = eglist[-1]
    return highest,lowest,first,last


egfunc(eglist)

(100, 6, 10, 100)


a,b,c,d = egfunc(eglist)
print(' a =',a,' b =',b,' c =',c,' d =',d)

 a = 100  b = 6  c = 10  d = 100


def implicitadd(x,y=3,z=0):
    print("%d + %d + %d = %d"%(x,y,z,x+y+z))
    return x+y+z


implicitadd(4)

4 + 3 + 0 = 7

7


implicitadd(4,4)
implicitadd(4,5,6)
implicitadd(4,z=7)
implicitadd(2,y=1,z=9)
implicitadd(x=1)

4 + 4 + 0 = 8
4 + 5 + 6 = 15
4 + 3 + 7 = 14
2 + 1 + 9 = 12
1 + 3 + 0 = 4

4


def add_n(first,*args):
    "return the sum of one or more numbers"
    reslist = [first] + [value for value in args]
    print(reslist)
    return sum(reslist)


add_n(1,2,3,4,5)

[1, 2, 3, 4, 5]

15


add_n(6.5)

[6.5]

6.5


def namedArgs(**names):
    'print the named arguments'
    # names is a dictionary of keyword : value
    print("  ".join(name+"="+str(value) 
                    for name,value in names.items()))

namedArgs(x=3*4,animal='mouse',z=(1+2j))

x=12  animal=mouse  z=(1+2j)


def firstfunc():
    x=1
    def secondfunc():
        x=2
        print("Inside secondfunc x =", x) 
    secondfunc()
    print("Outside x =", x)

x=0
firstfunc()
print("Global x =",x)

Inside secondfunc x = 2
Outside x = 1
Global x = 0


can_access = False
def update_access():
    can_access = True

update_access()
print(can_access) # will still print out False

False


can_access = False
def update_access():
    global can_access
    can_access = True

update_access()
print(can_access) # will still print out False

True


def which_scope():
    my_age = 49 # local variable my_age
    def inner_scope():
        nonlocal my_age
        my_age += 1 # Issue when we try to run this line.
        print(my_age)
    inner_scope()

which_scope()

50


add = lambda a, b : a + b
print(add(5, 12))

17


def double(x):
    return 2*x
def square(x):
    return x*x
def f_of_g(f,g):
    "Compose two functions of a single variable"
    return lambda x : f(g(x))

doublesquare= f_of_g(double,square)
print("doublesquare is a",type(doublesquare))
doublesquare(3)

doublesquare is a <class 'function'>

18


numbers = [4, 7, 12, 33, 13, 67]
remove = numbers.pop
print(remove())
print(remove(0))

67
4


numbers = [1, 2, 3, 4, 5, 6]
def is_mult_of_three(n):
    return n % 3 == 0
    
list(filter(is_mult_of_three, numbers))

[3, 6]


def pass_function(function_name, **args):
    """Takes a function as an argument
    Passes the argument 'l' to the function passed in 
    """
    print("This function takes another function as an argument")
    function_name(f=args['l'])

def print_arguments( **args ):
    """Prints the arguments"""
    print(f'The arguments are {args}')
    
pass_function(print_arguments, l='spam')

This function takes another function as an argument
The arguments are {'f': 'spam'}


def my_decorator(func):
    def wrapper():
        print("The function has not been called yet. Let's call it.")
        func()
        print("The function was called and has returned a result.")
    # returns the wrapper function itself!
    return wrapper

@my_decorator
def say_hello():
    print("Hello, world!")
    
say_hello()

The function has not been called yet. Let's call it.
Hello, world!
The function was called and has returned a result.


@my_decorator
def greet():
    print("Greetings!")
    
greet()

The function has not been called yet. Let's call it.
Greetings!
The function was called and has returned a result.


def define_units(unit):
    """Define the units"""
    def decorator_define_units(func):
        func.unit = unit
        return func
    return decorator_define_units

@define_units('m^2')
def area(length, width):
    """Calculate area of rectangle or parallelogram"""
    return length * width

# The unit defined in the decorator can be used with dot notation
# In this case the function are units can be used as area.unit
print(f'The area is {area(3,5)}{area.unit}')

The area is 15m^2


def multiply(by = None):
    def multiply_real_decorator(function):
        def wrapper(*args,**kwargs):
            return by * function(*args,**kwargs)
        return wrapper
    return multiply_real_decorator

@multiply(by = 2)
def adder(a,b):
    return a + b

@multiply(by = 3)
def subtractor(a,b):
    return a - b

print(adder(2,3))
print(subtractor(2,3))

10
-3


class HelloWorld:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'Hello, world!'


class Car:
    def __init__(self, color, make, model, fueltype):
        self.color = color
        self.make = make
        self.model = model
        self.fueltype = fueltype

bullitt = Car('Green', 'Ford', 'Mustang', 'Gasoline')


class Bird:
   """ Bird class """
   def __init__(self, kind, call):
      #properties
       self.kind = kind
       self.call = call

   #behaviour
   def description(self):
       """ describe the bird """
       return f"A(n) {self.kind} goes {self.call}" 
       
owl = Bird('Owl', 'Twit Twoo!')
print(owl.description())

A(n) Owl goes Twit Twoo!


parrot = Bird('Parrot', 'Parrr!')
parrot.call

'Parrr!'


crow = Bird('Crow', 'Caaaw!')
crow.description()

'A(n) Crow goes Caaaw!'


crow.call = 'screech'
crow.description()

'A(n) Crow goes screech'


del crow.call


class Bird:
    """  Bird class  """
    # class attribute
    definition = "a warm-blooded egg-laying vertebrate animal distinguished by the possession of feathers, wings, a beak, and typically by being able to fly."

    def __init__(self, kind, call):
        self.kind = kind   # instance attribute
        self.call = call   # instance attribute

    def description(self):
        """  describe the bird  """
        return f"A(n) {self.kind} goes {self.call}" 
       
owl = Bird('Owl', 'Twit Twoo!')
print(owl.description())# class method called trough instance
print(owl.definition)   # this is class property accessed through instance
print(owl.call)         # this is instance property

A(n) Owl goes Twit Twoo!
a warm-blooded egg-laying vertebrate animal distinguished by the possession of feathers, wings, a beak, and typically by being able to fly.
Twit Twoo!


class Bird:
    """  Bird class  """
    # class attribute
    definition = "a warm-blooded egg-laying vertebrate animal distinguished by the possession of feathers, wings, a beak, and typically by being able to fly."

    def __init__(self, kind, call):
        self.kind = kind  # instance attribute
        self.call = call  # instance attribute

    def description(self):
        """  describe the bird  """
        return f"A {self.kind} goes {self.call} and is {self.definition}"

class Parrot(Bird):
    def __init__(self, color):
        Bird.__init__(self, 'Parrot', 'Kah!') # call the parent's init method
        self.color = color  # subclass attribute, eadditional to the inherited attributes

parrot = Parrot('blue')
print(parrot.color)
print(parrot.description())

blue
A Parrot goes Kah! and is a warm-blooded egg-laying vertebrate animal distinguished by the possession of feathers, wings, a beak, and typically by being able to fly.


class SuperClass:
    """This is the base or parent class"""
    def __init__(self, x):
        self.x = x
    def result(self):
        """Method returns a variable x"""
        return self.x

class Mixin:
    """This mixin can be used with any class"""
    def prettify_string(self, a):
        """Method that returns a string containing variables c and d"""
        c, d = a # Unpacks the tuple a into variables c and d
        return f'{c}, {d}!'

class SubClass1(Mixin, SuperClass):
    def __init__(self, x, y):
        """Inherits x from SuperClass and extends with variable y"""
        SuperClass.__init__(self, x)
        self.y = y
    def result1(self):
        """Returns a tuple of x and y"""
        return self.x, self.y
    
class SubClass2(Mixin, SuperClass):
    def __init__(self, x, z):
        """Inherits x from SuperClass and extends with variable z"""
        SuperClass.__init__(self, x)
        self.z = z
    def result2(self):
        """Returns a tuple of x and z"""
        return self.x, 2 * self.z

hello = SubClass1('Hello', 'World')
world = SubClass2('Hello', 'World')

print(hello.prettify_string(hello.result1()))
print(world.prettify_string(world.result2()))

Hello, World!
Hello, WorldWorld!


class Employee:
    """
    Base class for employees
    """
    # class attribute
    employee_no = 0

    def __init__(self, name, no_of_years):
        # instance attribute
        self.name = name
        self.no_of_years = no_of_years
        Employee.employee_no += 1
        self.employee_no = Employee.employee_no

    def details(self):
        """
        Method to return employee details as a string
        """
        return f"Name: {self.name}\n Years Worked: {self.no_of_years}\n Employee Number: {self.employee_no}\n"


class HolidayMixin:
    """
    Mixin to calculate holiday entitlement by years of service.
    Note that a mixin has no __init__ as you cannot create an instance of a mixin
    """
    def calculate_holidays(self, no_of_years):
        """
        Method that returns holidays as an integer if given no of years of service
        """
        BASE_HOLIDAY = 20
        bonus = 0
        holidays = BASE_HOLIDAY
        if no_of_years < 3:
            bonus = holidays + 1
        elif no_of_years <= 5:
            bonus = holidays + 2
        elif no_of_years > 5:
            bonus = holidays + 3
        return f'Holidays: {bonus}'


class DirectDeveloper(HolidayMixin, Employee):
    """
    Class for direct developer employee inheriting from 
    Employee class but also inheriting from HolidayMixin
    """
    def __init__(self, name, no_of_years, prog_lang):
        self.prog_language = prog_lang
        Employee.__init__(self, name, no_of_years)

    def calculate_salary(self):
        """
        Returns salary plus bonus as an integer
        """
        base = 30000
        if self.prog_language.lower() == 'python':
            bonus = base * 0.10
        else:
            bonus = 0
        return base + bonus

    def get_details(self):
        """
        Method to return direct developer details as a string
        Uses details() method inherited from Employee super class
        """
        return Employee.details(self) + f'Programming Language: {self.prog_language}'


eric = DirectDeveloper("Eric Praline", 2, "python")

# Prints out all the attributes of your eric instance using get_details method from DirectDeveloper
# If you use the details method from Employee then the Programming Language will not print
print(eric.get_details())
# The mixin method is usable for instance eric
print(eric.calculate_holidays(eric.no_of_years))
# Uses the calculate_salary method from DirectDeveloper
print(f'${eric.calculate_salary()}')

luigi = DirectDeveloper("Luigi Vercotti", 10, "php")
print(luigi.get_details())
print(luigi.calculate_holidays(luigi.no_of_years))
print(f'${luigi.calculate_salary()}')

Name: Eric Praline
 Years Worked: 2
 Employee Number: 1
Programming Language: python
Holidays: 21
$33000.0
Name: Luigi Vercotti
 Years Worked: 10
 Employee Number: 2
Programming Language: php
Holidays: 23
$30000


class Vehicle:
    def __init__(self, make, model):
        self.make = make
        self.model = model

class Engine:
    def __init__(self, capacity, fuel):
        self.capacity = capacity
        self.fuel = fuel
    
class InternalCombustion(Vehicle, Engine):
    def __init__(self, make, model, capacity, fuel):
        Vehicle.__init__(self, make, model)
        Engine.__init__(self, capacity, fuel)
        
class Electric(Vehicle):
    def __init__(self, make, model):
        Vehicle.__init__(self, make, model)
        
volkswagen = InternalCombustion("Volkswagen", "Golf", 1.7, "Diesel")
tesla = Electric("Tesla", "X")


class Employee:
    """
    Base class for employees
    """
    # class attribute
    employee_no = 0

    def __init__(self, fname, sname, no_of_years):
        # instance attribute
        self.fname = fname
        self.sname = sname
        self.no_of_years = no_of_years
        Employee.employee_no +=1
        self.employee_no = Employee.employee_no

    def details(self):
        """
        Method to return employee details as a string
        """
        return f"First Name: {self.fname}\n Surname: {self.sname}\n Years Worked: {self.no_of_years}\n Employee Number: {self.employee_no}\n"

class ExternalContract:
    """
    Class for contract employees
    """

    def __init__(self, contract_cost):
        self.contract_cost = contract_cost

    def cost(self):
        """
        Returns the contract cost added to the salary
        """
        return self.contract_cost + 30000


class HolidayMixin:
    """
    Mixin to calculate holiday entitlement by years of service.
    """
    def calculate_holidays(self, no_of_years):
        """
        Returns holidays as an integer
        """
        BASE_HOLIDAY = 20
        bonus = 0
        holidays = BASE_HOLIDAY
        if self.no_of_years < 3:
            bonus = holidays + 1
        elif self.no_of_years <= 5:
            bonus = holidays + 2
        elif self.no_of_years > 5:
            bonus = holidays + 3
        return f'Holidays: {bonus}'


class DirectDeveloper(HolidayMixin, Employee):
    """
    Class for direct developer employee inheriting from 
    Employee class. 
    """
    def __init__(self, fname, sname, no_of_years, prog_lang):
        self.prog_language = prog_lang
        Employee.__init__(self, fname, sname, no_of_years)

    def calculate_salary(self):
        """
        Returns salary plus bonus as an integer
        """
        base = 30000
        if self.prog_language.lower() == 'python':
            bonus = base * 0.10
        else:
            bonus = 0
        return base + bonus

    def details(self):
        """
        Method to return direct developer details as a string
        """
        return Employee.details(self) + f'Programming Language: {self.prog_language}'


class ContractDeveloper(HolidayMixin, Employee, ExternalContract):
    """
    Class is subclass of Employee, composition relationship
    with ExternalContract and using HolidayMixin
    """
    def __init__(self, fname, sname, no_of_years, prog_language, contract_cost):
        self.prog_language = prog_language
        self.contract_cost = contract_cost
        Employee.__init__(self, fname, sname, no_of_years)   

    def details(self):
        """
        Returns inherited details plus contract cost
        """
        return Employee.details(self) + f'Programming Language: {self.prog_language}\n Contract cost: {ExternalContract.cost(self)}'


dev = DirectDeveloper("Eric", "Praline", 2, "python")
# There is no composition relationship here. A DirectDeveloper is an Employee
print(dev.details())
print(dev.calculate_holidays(dev.no_of_years))
print(f'${dev.calculate_salary()}')

contractor = ContractDeveloper("Luigi", "Vercotti", 10, "python", 100000)
# When the contractor details are printed the Contract cost is obtained from ExternalContract class
# There is a composition relationship as contractor has an ExternalContract
# However, an external contract is not an employee
# ExternalContract is an object that could be reused by many other objects. 
print(contractor.details())
# The mixin can also be used
print(contractor.calculate_holidays(contractor.no_of_years))

First Name: Eric
 Surname: Praline
 Years Worked: 2
 Employee Number: 1
Programming Language: python
Holidays: 21
$33000.0
First Name: Luigi
 Surname: Vercotti
 Years Worked: 10
 Employee Number: 2
Programming Language: python
 Contract cost: 130000
Holidays: 23


class Rectangle:
    def __init__(self, height, width):
        self.height = height
        self.width = width

    def area(self):
        return self.height * self.width

    def perimeter(self):
        return 2 * (self.height + self.width)


class Square(Rectangle):
    def __init__(self, height):
        super().__init__(height, height)  # here we use the super() instead of Rectangle


class Bird:
    """ Bird class  """
    # class attribute
    definition = "a warm-blooded egg-laying vertebrate animal distinguished by the possession of feathers, wings, a beak, and typically by being able to fly."

    def __init__(self, kind, call):
        self.kind = kind  # instance attribute
        self.call = call  # instance attribute

    def description(self):
        """  describe the bird """
        return f"A {self.kind} goes {self.call} and is {self.definition}" 

class Parrot(Bird):
    def __init__(self, color):
        Bird.__init__(self, 'Parrot', 'Kah!')
        self.color = color


parrot = Parrot('blue')
print(parrot.color)
print(parrot.description())  #this is originally the Bird class's method, inherited into Parrot

blue
A Parrot goes Kah! and is a warm-blooded egg-laying vertebrate animal distinguished by the possession of feathers, wings, a beak, and typically by being able to fly.


class Bird(object):
    """  Bird superclass  """
    def __init__(self, kind, call):
        self.kind = kind  # instance attribute
        self.call = call  # instance attribute

    def description(self):
        """  Returns description string including instance attributes  """
        return f'A {self.kind} goes {self.call}'

class Fowl(Bird):
    """  Subclass of the superclass Bird  """
    def __init__(self, kind, call, category):
        self.__fowl_types = {'landfowl': 'Landfowl is an order of heavy-bodied ground-feeding birds that includes turkey, grouse, chicken, New World quail and Old World quail, ptarmigan, partridge, pheasant, junglefowl and the Cracidae',
                            'waterfowl': 'Waterfowl is an order of birds that comprises about 180 living species in three families: Anhimidae (the screamers), Anseranatidae (the magpie goose), and Anatidae,the largest family, which  includes over 170 species of waterfowl, among them the ducks, geese, and swans.'}
        self.category = category
        super().__init__(kind, call) # Uses super() function to state kind, call from superclass Bird

    @property # make a Read-Only property out of a method
    def fowl_type(self):
        return self.__fowl_types[self.category.lower()]

    def description(self):
        """ Returns string from superclass description method and appends a string to include additional information """
        return f'{super().description()} \nSome interesting facts about the {self.kind} : A {self.kind} is of type {self.category}. {self.fowl_type}'

mute = Fowl('Swan', 'honk', 'Waterfowl')
print(mute.description())
print(mute.fowl_type) # <= the decorator makes it possible to treat the function as a property

A Swan goes honk 
Some interesting facts about the Swan : A Swan is of type Waterfowl. Waterfowl is an order of birds that comprises about 180 living species in three families: Anhimidae (the screamers), Anseranatidae (the magpie goose), and Anatidae,the largest family, which  includes over 170 species of waterfowl, among them the ducks, geese, and swans.
Waterfowl is an order of birds that comprises about 180 living species in three families: Anhimidae (the screamers), Anseranatidae (the magpie goose), and Anatidae,the largest family, which  includes over 170 species of waterfowl, among them the ducks, geese, and swans.


i = 10 + 20
print(i)

30


language = "Python"
version = 3
f'We are using {language}{version}'

'We are using Python3'


import math
# Here the format specifier .2f is used to truncate at 2 decimal places
f'The value of pi to 2 decimal places is {math.pi:.2f}'

'The value of pi to 2 decimal places is 3.14'


# The currency symbol for pounds sterling has Unicode character number 163
pound = chr(163)
tabulate = {'Egg & Spam': 1, 'Egg, Bacon & Spam': 1.5, 'Egg, Bacon Sausage & Spam': 2, }
# Loops over a dictionary of menu items as keys and prices as values
for item, price in tabulate.items():
    # The format specifiers here denote a minimum width of 25 and 5 characters
    print(f'{item:25} - {pound}{price:5}')

Egg & Spam                - £    1
Egg, Bacon & Spam         - £  1.5
Egg, Bacon Sausage & Spam - £    2


for number in range(3, 0, -1):
    print(f"{number} bottle(s) of beer on the wall. {number} bottle(s) of beer")
    print(f"Take one down, pass it around. {number-1} bottle(s) of beer on the wall\n")

3 bottle(s) of beer on the wall. 3 bottle(s) of beer
Take one down, pass it around. 2 bottle(s) of beer on the wall

2 bottle(s) of beer on the wall. 2 bottle(s) of beer
Take one down, pass it around. 1 bottle(s) of beer on the wall

1 bottle(s) of beer on the wall. 1 bottle(s) of beer
Take one down, pass it around. 0 bottle(s) of beer on the wall


f = open('./img/fourlines.txt', 'r')
lines = f.readlines()
f.close()
print(lines)

['This is the first line\n', 'And this is the second\n', 'Here is the third line\n', 'And here the fourth']


import re
import collections

text = open('./img/book.txt', 'r').read().lower()
words = re.findall('\w+', text)
print(collections.Counter(words).most_common(10))

[('the', 28), ('to', 21), ('i', 15), ('a', 13), ('and', 12), ('he', 12), ('of', 11), ('her', 11), ('you', 11), ('be', 10)]


f = open('./img/newfile.txt', 'w')
f.write('Hello!')
f.close()


f = open('./img/newfile.txt', 'a')
lines = ['Hello','World','Welcome','To','File IO']
text = '\n'.join(lines)
f.writelines(text)
f.close()


from requests_html import HTMLSession

session = HTMLSession()
# Makes a GET request to Wikipedia Web Scraping page
r = session.get('https://en.wikipedia.org/wiki/Web_scraping')
# Selects the heading element with ID firstHeading
# The optional first=True avoids a list being returned
heading = r.html.find('#firstHeading', first=True)
# Grabs the text from that h1
# Without first=True you would then have to use heading[0].text
print(heading.text)
# prints the inner HTML content for that h1 element
print(heading.html)

Web scraping
<h1 id="firstHeading" class="firstHeading">Web scraping</h1>


import http.server
import socketserver

PORT=5500 # A port is a communication endpoint where a computer can link to a network

replacements = {
    'index.html': {'template': './img/template.html',   '{link}': 'contact', 
                   '{title}': 'Landing Page',           '{heading}': 'Welcome',
                   '{body}': 'This is my cool website', '{footer}': 'Made with a framework'},
    'contact.html': {'template': './img/template.html', '{link}': 'index',
                     '{title}': 'Contact Me',           '{heading}': 'Get In Touch',
                     '{body}': 'me@example.com',        '{footer}': 'Made with a framework'},
}

index = open('index.html', 'w')
contact = open('contact.html', 'w')
newindex = open(replacements['index.html']['template'], 'r')
newcontact = open(replacements['contact.html']['template'], 'r')

# This outer loop iterates through each line in newindex
for line in newindex:
    # This inner loop iterates through the key:value pairs in the items of the replacements['index.html'] dictionary 
    for src, target in replacements['index.html'].items():
        # Here we replace the key with the value
        line = line.replace(src, target)
    index.write(line)

for line in newcontact:
    for src, target in replacements['contact.html'].items():
        line = line.replace(src, target)
    contact.write(line)

index.close()
contact.close()
newindex.close()
newcontact.close()

# The code below serves html files relative to the current directory
# The port number is the PORT constant value set at the top of the file
Handler = http.server.SimpleHTTPRequestHandler

with socketserver.TCPServer(("", PORT), Handler) as httpd:
    print("serving at port", PORT)
    print(f"access the generated web page through this link: http://localhost:{PORT}")
    # uncomment the following line to make it work
    #httpd.serve_forever()

serving at port 5500
access the generated web page through this link: http://localhost:5500


def encode_name(name):
    try:
        name = name.encode('ascii')
    except UnicodeError as e:
        print(f'The name {e.object} has a character at position {e.start}',
              f'that cannot be encoded in {e.encoding} due to {e.reason}')
    return name
    
encode_name('Stéfan')

The name Stéfan has a character at position 2 that cannot be encoded in ascii due to ordinal not in range(128)

'Stéfan'


try:
    f = open('neverland.txt')
    s = f.readline()
except OSError as e:
    errno, strerror = e.args
    print(f"An I/O error occured. #{errno}: {strerror}.")

An I/O error occured. #2: No such file or directory.


def linecount(filename):
    """
    Counts the lines in a text file.
    Prints the opening line of a text file. 
    """
    try:
        f = open(filename, 'r')
        s = f.readlines()
    except OSError as e:
        # OSError exception is used as it deals with system errors such as I/O errors
        # OSError returns an error code (errno) and message (strerror)
        errno, strerror = e.args
        print(f"An I/O error occured. #{errno}: {strerror}.")
    else:
        # This is the code that does the line counting
        print(f'{filename} is {len(s)} lines long.')
        print(f"The opening line of {filename} is '{s[0]}'")
        f.close()
    finally:
        # This will print whether the line count has been successful or not
        print(f'Finished with {filename}.')
    
linecount('./img/gulliver.txt')
print()
linecount('./img/swift.txt')

./img/gulliver.txt is 14 lines long.
The opening line of ./img/gulliver.txt is 'My father had a small estate in Nottinghamshire; I was the third of five
'
Finished with ./img/gulliver.txt.

An I/O error occured. #2: No such file or directory.
Finished with ./img/swift.txt.


def linecount(filename):
    """
    Counts the lines in a text file.
    Prints the opening line of a text file. 
    """
    try:
        with open(filename, 'r') as f:
            s = f.readlines()
    except OSError as e:
        errno, strerror = e.args
        print(f"An I/O error occured. #{errno}: {strerror}.")
    else:
        print(f'{filename} is {len(s)} line long.')
        print(f"The opening line of {filename} is '{s[0]}'")
    finally:
        print(f'Finished with {filename}.')
        
linecount('gulliver.txt')
print()
linecount('swift.txt')

An I/O error occured. #2: No such file or directory.
Finished with gulliver.txt.

An I/O error occured. #2: No such file or directory.
Finished with swift.txt.


try:
    count=0
    while True:
        while True:
            while True:
                print("Looping")
                count = count + 1
                if count > 3:
                    raise Exception("abort") # exit every loop or function
                if count > 4:
                    raise StopIteration("I'm bored") # built in exception type
except StopIteration as e:
    print("Stopped iteration:",e)
except Exception as e: # this is where we go when an exception is raised
    print("Caught exception:",e)
finally:
    print("All done")

Looping
Looping
Looping
Looping
Caught exception: abort
All done


try:
    for i in [2,1.5,0.0,3]:
        inverse = 1.0/i
except Exception as e: # no matter what exception
    print("Cannot calculate inverse because:", e)

Cannot calculate inverse because: float division by zero


import math

print(math.pi)

print(math.sqrt(4))

3.141592653589793
2.0


from datetime import datetime

x = datetime.now()
print(x)

2021-04-23 09:22:30.041620


x.year

2021


x.strftime("%A")

'Friday'


str(datetime.now().date())

'2021-04-23'


str(datetime.now().time())

'09:22:30.110629'


import os
print(os.getcwd())

C:\Users\ruszk\Google Drive\Learning\Python


print(os.listdir('./img/'))

['0+none.png', 'animal-class.png', 'arithmetic+operators.png', 'assignment+operators.png', 'book.txt', 'break+continue+pass.png', 'bug.png', 'car-class.png', 'class+method.png', 'class+mixin.png', 'class-properties.png', 'comparison+operators.png', 'containment.png', 'converting+between+data+types.png', 'data-types.png', 'datetime.png', 'decorator.png', 'dictionary-comprehension.png', 'dictionary-items.png', 'dictionary.png', 'errors.txt', 'f-string.png', 'file-open-modes.png', 'flask+about-1.png', 'flask+hello-world+tags.png', 'flask+hello-world.png', 'flask+home-1.png', 'flask-for+loop.png', 'flask-form-after.png', 'flask-form-before.png', 'flask-usage.png', 'for+loop.png', 'fourlines.txt', 'frameworks+modules+libraries.png', 'function+call.png', 'function+parameter+return.png', 'function.png', 'gulliver.txt', 'ide.png', 'if+elif+else.png', 'if+else.png', 'import.png', 'indentation.png', 'input+output.png', 'input-from-user.png', 'is+is-not.png', 'list-comprehension.png', 'list-indexing.png', 'list-slicing.png', 'logical+operators.png', 'naming-convention.png', 'nested+if+indentation.png', 'nested-data-structure.png', 'nested-loops.png', 'newfile.txt', 'nonetype.png', 'os-path.png', 'os.png', 'print+hello-world.png', 'random.png', 'read-file.png', 'read-web.png', 'reserved-keywords.png', 'runtime-errors.png', 'scope-keywords.png', 'scope.png', 'set.png', 'splat+args+kwargs.png', 'sqlite+chinook-closed.png', 'sqlite+chinook-open-db.png', 'sqlite+chinook-opened.png', 'sqlite+chinook-schema.png', 'sqlite+chinook-tables.png', 'sqlite+chinook-terminal.png', 'sqlite+path.png', 'string.png', 'subclass+inheritance.png', 'syntax-error.png', 'sys-files.png', 'system-exit.png', 'template.html', 'ternary+operator.png', 'try+except+else+finally.png', 'try+except.png', 'tuple.png', 'varable+assignment.png', 'web-server.png', 'while+loop.png']


import os
# This is how you would join two paths in your code
print(os.path.join('/home/runner/', 'os'))

path = "/home/runner/os/main.py"
# Splits the path into a pair (head, tail) where the tail is the end of the pathname
# The tail is after the / and the head is the pathname up to that point 
(dirname, filename) = os.path.split(path)
print(f'The directory path is {dirname}')
print(f'The filename is {filename}')
# Splits the filename into a pair (root, ext)
# The root is before the dot and the ext contains the dot with the suffix after it
(module, extension) = os.path.splitext(filename)
print(f'The module is {module}')
print(f'Its file suffix is {extension}')

/home/runner/os
The directory path is /home/runner/os
The filename is main.py
The module is main
Its file suffix is .py


import sys
sys.getrecursionlimit()

3000


sys.version

'3.8.5 (default, Sep  3 2020, 21:29:08) [MSC v.1916 64 bit (AMD64)]'


sys.platform

'win32'


sys.path

['C:\\Users\\ruszk\\Google Drive\\Learning\\Python',
 'C:\\ProgramData\\Anaconda3\\python38.zip',
 'C:\\ProgramData\\Anaconda3\\DLLs',
 'C:\\ProgramData\\Anaconda3\\lib',
 'C:\\ProgramData\\Anaconda3',
 '',
 'C:\\Users\\ruszk\\AppData\\Roaming\\Python\\Python38\\site-packages',
 'C:\\ProgramData\\Anaconda3\\lib\\site-packages',
 'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\win32',
 'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\win32\\lib',
 'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\Pythonwin',
 'C:\\ProgramData\\Anaconda3\\lib\\site-packages\\IPython\\extensions',
 'C:\\Users\\ruszk\\.ipython']


import random

print(f'A random float between 0 & 1.0: {random.random()}')
print(f'A random int between 0 & 10: {random.randrange(11)}')
print('A random choice from a list: ' + random.choice(['paper', 'scissors', 'rock']))
deck = ['hearts', 'diamonds', 'spades', 'clubs']
random.shuffle(deck)
print(deck)

A random float between 0 & 1.0: 0.4913461104112826
A random int between 0 & 10: 9
A random choice from a list: paper
['spades', 'hearts', 'clubs', 'diamonds']


import numpy as np 
a = np.array([1, 2, 3])
print(a)

[1 2 3]


from dateutil import parser 
log_line = 'INFO 2020-07-03T23:27:51 Shutdown complete.'
timestamp = parser.parse(log_line, fuzzy=True)
print(timestamp)

2020-07-03 23:27:51


import numpy as np


x = np.array([1,2,3,4,5])
y = np.array([2*i for i in x])
x+y # element wise addition

array([ 3,  6,  9, 12, 15])


X = x[:4].reshape(2,2) # turn into a matrix/table
2*X # multiply by a scalar

array([[2, 4],
       [6, 8]])


Y = np.matrix(X)
print("X=Y=\n",Y)
print("array X*X=\n",X*X,'\nmatrix Y*Y=\n',Y*Y)

X=Y=
 [[1 2]
 [3 4]]
array X*X=
 [[ 1  4]
 [ 9 16]] 
matrix Y*Y=
 [[ 7 10]
 [15 22]]


import numpy as np
import matplotlib.pyplot as plt


plt.plot([1,4,2,3])
plt.ylabel('some numbers')
plt.show() # optional


data="""
4,1
2,5
9,2
6,3
6,7
8,4
"""
# crude parsing of CSV data - use csv module for reading csv files
xy = [ [float(i) for i in line.strip().split(",")]
      for line in data.split()]
x = [ pt[0] for pt in xy]
y = [ pt[1] for pt in xy]
plt.plot(x,y,"r*")
plt.show()


# A slightly more complicated plot with the help of numpy
X = np.linspace(-np.pi, np.pi, 256, endpoint=True)
C, S = np.cos(X), np.sin(X)  # create arrays of function values for each X value

plt.plot(X, C)
plt.plot(X, S)

plt.show()


t = np.arange(0.0, 5.0, 0.01)
line, = plt.plot(t, np.cos(2*np.pi*t), lw=2)
plt.annotate('local max', xy=(2, 1), xytext=(3, 1.5),
            arrowprops=dict(facecolor='black', shrink=0.05),
            )
# text can include basic LaTeX commands - but need to mark
# string as raw (r"") or escape '\' (by using '\\')
plt.text(1,-1.5,r"Graph of $cos(2\pi x)$") 
plt.ylim(-2,2)
plt.show()


from scipy.stats import * # for multivariate_normal to define our surface
delta = 0.025
x = np.arange(-3.0, 3.0, delta)
y = np.arange(-2.0, 2.0, delta)
X, Y = np.meshgrid(x, y) # define mesh of points
pos = np.empty(X.shape + (2,))
pos[:, :, 0] = X; pos[:, :, 1] = Y
rv1 = multivariate_normal([0, 0], [[1.0, 0.0], [0.0, 1.0]])
rv2 = multivariate_normal([1, 1], [[1.5, 0.0], [0.0, 0.5]])
#Z1 = bivariate_normal(X, Y, 1.0, 1.0, 0.0, 0.0)
#Z2 = bivariate_normal(X, Y, 1.5, 0.5, 1, 1)
Z1 = rv1.pdf(pos)
Z2 = rv2.pdf(pos)
Z = 10.0 * (Z2 - Z1) # difference of Gaussians

# Create a simple contour plot with labels using default colors.  The
# inline argument to clabel will control whether the labels are draw
# over the line segments of the contour, removing the lines beneath
# the label
plt.figure()
CS = plt.contour(X, Y, Z)
plt.clabel(CS, inline=1, fontsize=10)
plt.title('Simplest default with labels')
plt.show()


CS = plt.contour(X, Y, Z)
plt.clabel(CS, inline=1, fontsize=10)
plt.title('Simplest default with labels')
# uncomment the following lines to make it work
#plt.savefig("surface_ex.png")
#plt.savefig("surface_ex.pdf")

Text(0.5, 1.0, 'Simplest default with labels')


for ext,description in plt.gcf().canvas.get_supported_filetypes().items():
    print("%s: \t%s" % (ext,description))

eps: 	Encapsulated Postscript
jpg: 	Joint Photographic Experts Group
jpeg: 	Joint Photographic Experts Group
pdf: 	Portable Document Format
pgf: 	PGF code for LaTeX
png: 	Portable Network Graphics
ps: 	Postscript
raw: 	Raw RGBA bitmap
rgba: 	Raw RGBA bitmap
svg: 	Scalable Vector Graphics
svgz: 	Scalable Vector Graphics
tif: 	Tagged Image File Format
tiff: 	Tagged Image File Format

<Figure size 432x288 with 0 Axes>

Function	What it converts
int()	Converts to an integer
float()	Converts to a floating-point number
hex()	Converts a number to a hexadecimal string
oct()	Converts a number to a octal string
tuple()	Converts to a tuple
set()	Converts to a set
list()	Converts to a list
dict()	Converts a tuple into a dictionary
str()	Converts a number into a string

Symbol	Task Performed
+	Addition
-	Subtraction
/	Division
//	Integer division
%	Modulus (remainder)
*	Multiplication
**	Exponentiation (power)

Symbol	Task Performed
==	True, if it is equal
!=	True, if not equal to
<	less than
>	greater than
<=	less than or equal to
>=	greater than or equal to

Operator	Meaning	\		Symbol
`and`	Logical AND	\|	&	Bitwise AND
`or`	Logical OR	\|	$\mid$	Bitwise OR
`not`	Not	\|	~	Negate
		\|	^	Exclusive OR
		\|	>>	Right shift
		\|	<<	Left shift

Method	Description
`capitalize()`	Capitalizes the first character of the string
`center()`	Centers string
`count()`	Returns a count of times a specified value occurs in the string
`encode()`	Returns an encoded version of the string (use decode() to decode)
`endswith()`	Returns True if the string ends with a specified suffix
`expandtabs()`	Sets the tab size in spaces of the string
`find()`	Returns the lowest index position of where a specified character was found
`index()`	Searches for a specified value and returns the position of where it was found or an error if not found
`isalnum()`	Returns True if all characters are alphanumeric
`isalpha()`	Returns True if all characters are alphabetic
`isdigit()`	Returns True if all characters are digits
`islower()`	Returns True if all characters are lower case
`isspace()`	Returns True if all characters are whitespace
`istitle()`	Returns True if the string is titlecased
`isupper()`	Returns True if all characters in the string are upper case
`join()`	concatenates string
`ljust()`	Returns a left justified version of the string
`lower()`	Converts a string into lower case
`lstrip()`	Returns a left trim version of the string
`partition()`	Returns a tuple where the string is parted into two strings and the separator
`replace()`	Returns a string where a old value is replaced with a new value
`rfind()`	Searches highest index in the string for a specified value
`rindex()`	Same but with error if nothing found
`rjust()`	Returns a right justified version of the string
`rpartition()`	Returns a tuple where the string is parted into three parts
`rsplit()`	Splits the string at the specified separator, and returns a list
`rstrip()`	Returns a right trim version of the string
`split()`	Splits the string at the specified separator, and returns a list
`splitlines()`	Splits the string at line breaks and returns a list
`startswith()`	Returns true if the string starts with the specified value
`strip()`	Returns a trimmed version of the string
`swapcase()`	Swaps cases, lower case becomes upper case and vice versa
`title()`	Converts the first character of each word to upper case
`translate()`	Returns a translated string
`upper()`	Converts a string into uppercase
`zfill()`	Fills the string with a specified number of 0 values at the beginning

Method	Description
list.append(x)	Add an item to the end of the list.
list.extend(list)	Extend the list by appending another list.
list.insert(i, x)	nsert an item at a given position. The first argument is the index of the element before which to insert
list.remove(x)	Remove the first item from the list whose value is equal to x. It raises a ValueError if there is no such item.
list.pop(i)	Remove the item at the given position in the list, and return it. If no index is specified, a.pop() removes and returns the last item in the list.
list.clear()	Remove all items from the list.
list.index(x, start, end)	Return zero-based index in the list of the first item whose value is equal to x. Raises a ValueError if there is no such item.The optional arguments start and end are interpreted as in the slice notation.
list.count(x)	Return the number of times x appears in the list.
list.sort(key=None, reverse=False)	Sort the items of the list in place
list.reverse()	Reverse the elements of the list in place.
list.copy()	Return a copy of the list. Equivalent to `a[:]`

Method	Description
clear()	Removes all the elements from the dictionary
copy()	Returns a copy of the dictionary
fromkeys()	Returns a new dictionary with the specified keys and value
get(keyname, value)	Returns the value of the specified keyname. Used in the previous unit. Returns default None if the	keyname doesn't exist unless you override this default with a optional value.
items()	Returns a list containing a tuple for each key:value pair
keys()	Returns a list containing the dictionary's keys. Used in the previous unit.
pop()	Removes the element with the specified key
popitem()	Removes the last inserted key:value pair
setdefault()	Returns the value of the specified key. If the key does not exist: insert the key, with the specified value
update()	Updates the dictionary with the specified key:value pairs
values()	Returns a list of all the values in the dictionary. Used in the previous unit.

Method	Description
ceil()	Rounds a number up to the nearest integer
comb()	Returns the number of ways to choose k items from n items without repetition and order
dist()	Returns the Euclidean distance between two points (p and q), where p and q are the coordinates of that point
exp()	Returns E raised to the power of x
fabs()	Returns the absolute value of a number
factorial()	Returns the factorial of a number
floor()	Rounds a number down to the nearest integer
fmod()	Returns the remainder of x/y
fsum()	Returns the sum of all items in any iterable (tuples, arrays, lists, etc.)
isnan()	Checks whether a value is NaN (not a number) or not
perm()	Returns the number of ways to choose k items from n items with order and without repetition
pow()	Returns the value of x to the power of y
prod()	Returns the product of all the elements in an iterable
remainder()	Returns the closest value that can make numerator completely divisible by the denominator
sqrt()	Returns the square root of a number
trunc()	Returns the truncated integer parts of a number

Constant	Description
e	Returns Euler's number (2.7182...)
inf	Returns a floating-point positive infinity
nan	Returns a floating-point NaN (Not a Number) value
pi	Returns PI (3.1415...)
tau	Returns tau (6.2831...)

Introduction to Python¶

Contents¶

00 How to get started with running Python¶

Introduction¶

Installation¶

How to learn from this resource?¶

Using Notebooks¶

License¶

01 Basic data types and operations (numbers, strings)¶

Getting started¶

Basic syntax for statements¶

Reserved Keywords¶

The print() Statement¶

Commenting the code¶

Code Indentation¶

Breakpoints using raise SystemExit()¶

Syntax Errors¶

Logic Errors - Bugs¶

Bugs¶

Debugging & Problem Solving Philosophy¶

Asking for help¶

Variables & Values¶

Declaring Variables¶

Determining Data Type¶

Integers, Floats & Decimals¶

None¶

String Variables¶

Converting Between Data Types¶

Operators¶

Basic Math With Arithmetic Operators¶

Division /¶

Exponent **¶

Modulo %¶

Floor Division //¶

Operator Precedence¶

Assignment operators¶

Comparing Values With Comparison Operators¶

Logical and Bitwise Operators¶

Identity Operators: Identity versus equality¶

Checking Containment with Containment Operators¶

Python Frameworks, Modules and Libraries¶

Built-in Functions¶

Converting values¶

Mathematical functions¶

Simplifying Arithmetic Operations¶

Accepting User Inputs¶

02 String manipulation¶

Working with strings¶

The Print Statement¶

String Formating¶

The f-string¶

String Methods¶

Formatting¶

Inspecting Strings¶

String comparison operations¶

Accessing parts of strings¶

Breaking apart strings¶

Strings are immutable¶

Advanced string processing¶

03 Control Flow Statements: Conditionals¶

Conditionals¶

if¶

if-else¶

if-elif-else¶

Nested if-else statements¶

Ternary Operator¶

04 Control Flow Statements: Loops¶

for loop¶

range()¶

while loop¶

Controlling Iteration (break, continue & pass)¶

break¶

continue¶

pass¶

else statement on loops¶

FizzBuzz¶

Nested Loops¶

Data structures¶

05 Data structures: Lists¶

Indexing¶

The `print()` Statement¶

Breakpoints using `raise SystemExit()`¶

Division `/`¶

Exponent `**`¶

Modulo `%`¶

Floor Division `//`¶

`if`¶

`if`-`else`¶

`if`-`elif`-`else`¶

Nested `if`-`else` statements¶

`for` loop¶

`range()`¶

`while` loop¶

`break`¶

`continue`¶

`pass`¶

`else` statement on loops¶

`global`¶

`local`¶

The `init()` Method¶

The `self` keyword¶

Catching Generic Errors With `as`¶

`else` and `finally` Clauses¶