def count(data, target):
    n = 0
    for item in data:
        if item == target: # found a match
            n += 1
    return n

name = "Harry Potter"
m = count(name, 'r')
print(m)
print(count([1, 2, 3, 4, 3, 5, 6, 3, 3, 4, 5, 3], 3))

n = 10 # Using an identifier that is also used within the function
print("n before function call = ", n)
print(count([1, 2, 3, 4, 3, 5, 6, 3, 3, 4, 5, 3], 3))
print("n after function call = ", n) #Checking if n gets updated when executing the function

3
5
n before function call =  10
5
n after function call =  10

def contains(data, target):
    for item in data:
        if item == target: # found a match
            return True
            print("This statement will never get printed")
    return False

print(contains("Harry potter", 'r'))
print(contains("Harry potter", 'z'))

True
False

#The id() built-in function returns a unique integer that represents 
#the identity of an object. This is essentially its memory address.

def count(data, target):
    print("(Inside function) ID of data = ", id(data))
    print("(Inside function) ID of target = ", id(target))
    n = 0
    for item in data:
        if item == target: # found a match
            n += 1
    print("(Inside function) ID of n = ", id(n))
    return n

name = 'Harry Potter'
t = 'r'
print("ID of name = ", id(name))
print("ID of t = ", id(t))
m = count(name, t)
print("ID of m = ", id(m))

ID of name =  4374578608
ID of t =  4329571056
(Inside function) ID of data =  4374578608
(Inside function) ID of target =  4329571056
(Inside function) ID of n =  4329056624
ID of m =  4329056624

def contains(data, target):
    for item in data:
        if item == target: # found a match
            data.append(target)# Appends target to data
            return True            
    return False

D = [1, 2, 3]
print("D before checking 2", D)
contains(D, 2)
print("D after checking 2", D)

D before checking 2 [1, 2, 3]
D after checking 2 [1, 2, 3, 2]

def count(data, target="."):
    n = 0
    for item in data:
        if item == target: # found a match
            n += 1    
    return n

text = """I give Pirrip as my father’s family name, on the authority of his 
tombstone and my sister, Mrs Joe Gargery, who married the blacksmith. As 
I never saw my father or my mother, and never saw any likeness of either of 
them (for their days were long before the days of photographs), my first 
fancies regarding what they were like were unreasonably derived from their 
tombstones. The shape of the letters on my father’s, gave me an odd idea 
that he was a square, stout, dark man, with curly black hair. From the 
character and turn of the inscription, “Also Georgiana Wife of the Above,” 
I drew a childish conclusion that my mother was freckled and sickly. To 
five little stone lozenges, each about a foot and a half long, which 
were arranged in a neat row beside their grave, and were sacred to the 
memory of five little brothers of mine, who gave up trying to get a 
living, exceedingly early in that universal struggle, I am indebted for 
a belief I religiously entertained that they had all been born on their 
backs with their hands in their trousers-pockets, and had never taken 
them out in this state of existence.
"""
print(count(text)) #Counting sentences 
print(count(text, '\n')) #Counting lines
print(count(text, ' ') + count(text, '\n')) #Counting words
# Technically, the above are not a very accurate way to count sentences and words,
# but are okay for getting estimates.

5
16
216

def foo(a=10, b=20, c=30):
    return([a, b, c])
    
print(foo(1, 2, 3))
print(foo(2, 1, 3))
print(foo(b=2))
print(foo(b=1, c=2, a=3))

[1, 2, 3]
[2, 1, 3]
[10, 2, 30]
[3, 1, 2]

S = [1, 2, 3, 0]
print(all(S))
print(round(1.0013456, 4))
print(ord('#'))
L = [1, 2, 3, 4, 5, 6]
for i in reversed(L):print(i, end=", ")

False
1.0013
35
6, 5, 4, 3, 2, 1,

data = {'A':1, 'B':2, 'C':3}
i = iter(data)
j = data.values()
for k in i: print(k)
for k in j: print(k)
L = list(range(10))
print(L)

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

def factors1(n):         # generator that computes factors
    for k in range(1,n+1):
        if n % k == 0:  # divides evenly, thus k is a factor
            yield k     # yield this factor as next result

def factors2(n): # generator that computes factors
    k = 1
    while k*k < n: # while k < sqrt(n)
        if n % k == 0:
            yield k
            yield n//k
        k += 1
    if k*k == n: # special case if n is a perfect square
        yield k

print("Factors of 200")
for i in factors1(200): print(i, end=", ")
print("\nFactors of 200")
for i in factors2(200): print(i, end=", ")


def fibonacci():
    a = 0
    b = 1
    while True:     # keep going...
        yield a     # report value, a, during this pass
        future = a + b
        a = b       # this will be next value reported
        b = future  # and subsequently this

print("\nPrinting Fibonacci sequence...")
j=0
for i in fibonacci():
    if(j>20):break
    print(i, end=", ")
    j +=1

Factors of 200
1, 2, 4, 5, 8, 10, 20, 25, 40, 50, 100, 200, 
Factors of 200
1, 200, 2, 100, 4, 50, 5, 40, 8, 25, 10, 20, 
Printing Fibonacci sequence...
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765,

# Please note that all the code snippets within Jupyter are executed in a sequence 
# and not individually in isolation. So, if I print data, the dictionary data defined in
# a previous code segment will get printed
print(data)

# dat has not been defined within this module. Let's try to print it and see if it raises a NameError
#print(dat)

# We know that a dictionary does not support next method. Let's see if it causes AttributeError
# You will need to comment out the previous line
#print(data.next())

# Trying out other errors
#abs('Hello')
#int('3.14')
#data['D']
print(D)
D[5]

{'A': 1, 'B': 2, 'C': 3}
[1, 2, 3, 2]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[10], line 18
      6 # dat has not been defined within this module. Let's try to print it and see if it raises a NameError
      7 #print(dat)
      8 
   (...)
     15 #int('3.14')
     16 #data['D']
     17 print(D)
---> 18 D[5]

IndexError: list index out of range

try:
    fp = open('sample.txt')
except IOError as e:
    print('Unable to open the file:', e)
print("test")

def ask_age():
    age =-1 # an initially invalid choice
    while age <= 0:
        try:
            age = int(input('Enter your age in years:'))
            if age <= 0:
                print('Your age must be positive')
        except(ValueError, EOFError):
            print('Invalid response')

def ask_age1():
    age =-1 # an initially invalid choice
    while age <= 0:
        try:
            age = int(input('Enter your age in years:'))
            if age <= 0:
                print('Your age must be positive')
        except(ValueError, EOFError):
            pass

def ask_age2():
    age =-1 # an initially invalid choice
    while age <= 0:
        try:
            age = int(input('Enter your age in years:'))
            if age <= 0:
                print('Your age must be positive')
        except ValueError:
            print('That is an invalid age specification')
            raise
            print("After raise")
        except EOFError:
            print('There was an unexpected error reading input.')
            raise # let's re-raise this exception
    return age

#try:
#    age = ask_age2()
#except ValueError:
#    print('Something went wrong')

score = 40
print('Pass' if score >= 30 else 'Fail')

# A short code for printing the prime numbers smaller than n
n = 100
primes = [k for k in range(1, n) if (True if all([False for j in range(2, k) if (k%j == 0)]) else False)]
print(len(primes))

sq1 = {k*k for k in range(1, n+1)}
print(sq1)

sq2 = (k*k for k in range(1, n+1))
print([n for n in sq2])

sq3 = {k : k*k for k in range(1, n+1)}
print([sq3[key] for key in sq3])

data = 1, 2, 3, 4, 5
print(data)

def maxmin(data):
    return max(data), min(data)

mm = maxmin(data)
print(mm)

a, b, c, d = range(7, 11)
print("a, b, c, d = ", a, b, c, d)

maximum, minimum = maxmin(data)
print("Max = ", maximum)
print("Min = ", minimum)

for x, y in [(7, 2), (5, 8), (6, 4)]:
    print([x, y])

sq3 = {k : k*k for k in range(1, 10)}
for k, v in sq3.items():
    print(k, v)

i, j = 10, 20
print("i , j = ", i, ",", j)
i, j = j, i
print("i , j = ", i, ",", j)

def fibonacci():
        a, b = 0, 1
        while True:
            yield a
            a, b = b, a+b
            
for i in fibonacci():
    if (i > 100):break
    print(i, end=", ")

x = 10
def test():
    #x=20
    print(x)
test()
print(x)

def count(data, target):
    n = 0
    for item in data:
        if item == target: 
            n+=1
    return n
gpa = 3.56
major = 'CS'
grades = ['A-', 'B+', 'A-']
print("Number of A: ", count(grades, 'A'))

scream = print
scream("Hello")

a, b = -10, -20
print(max(a, b, key=abs))

def foo():
    def bar():
        print("bar")
    print("foo")
    bar()

foo()
#bar()

# Create a file named utility.py with the lines below uncommented
#print("Always executed")
#if __name__ == '__main__':
#    print("Executed when run as script and not when imported")
#def count1(data, target):
#    return len([1 for item in data if item == target])

from utility import count1

print(count1("This is a sentence", "s"))

from random import *

print(random())
print(randint(1, 100))
L = [1, 2, 3, 4, 5]
shuffle(L)
print(L)

R1 = Random()
R2 = Random()
print(R1.randint(1, 100))
print(R2.randint(1, 100))

ACOL106: Data Structures

(Recap: Python Module 3)

1. Functions

Return statement

Information passing

Mutable parameters

Default parameter values

Keyword parameter

Python's built-in functions

2. Iterators and genrators

Generators

3. Exception handling

Common Exception types

Raising an Exception

Catching an Exception

4. Additional Python conveniences

4.1 Conditional Expressions

4.2 Comprehension sytax

4.3 Packing and Unpacking of Sequences

Simultaneous Assignments

5. Scopes and Namespaces

First-Class Objects

6. Modules and the Import Statement

Creating a new module

Existing modules

Pseudo-Random Number Generation

7. Module endnote