
NAME = ""
COLLABORATORS = ""


# Print the philosophy of Python
import this


!python3 --version


!mkdir test


%cd test


!pwd


# YOUR CODE HERE
raise NotImplementedError()


print("hello world from Python!")


%%writefile helloworld.py
print("hello world from Python file!")


!python3 helloworld.py


"Hello world from Jupyter cell!"


x = "Hello world from Jupyter cell!" # this will not be printed by Juputer cell


x = "Hello world from Jupyter cell!"
x; # This will NOT be printed


x = 3
(x, type(x))


print(x + 1)   # Addition
print(x - 1)   # Subtraction
print(x * 2)   # Multiplication
print(x ** 2)  # Exponentiation (not available in C)


x += 1    # x = x + 1 
print(x)
x *= 2    # x = x * 2
print(x)


x = 0.2 + 0.1
abs(x - 0.3) < 1e-15


t = True; f = False
print(type(t))


print(t and f) # Logical AND;
print(t or f)  # Logical OR;
print(not t)   # Logical NOT;
print(t != f)  # Logical XOR;


n = None
type(None), type(n)


hello = 'he"llo'   # String literals can use single quotes
world = "world'"   # or double quotes; it does not matter
great = """Python
also has triple quotes
which can internally contain 
newlines, 'single quotes' and "double quotes". 
Triple quotes are often used for documentation
and multi-line comments.
"""
print(hello)
print(len(hello))


hw = hello + ', ' + world  # String concatenation
print(hw)


num = 12
hw12 = f'{hello:s} {world} {num:d}'  # string formatting
hw12


"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.


hw12 = '%s %s %d' % (hello, world, 12) # C-style string formatting using % operator
hw12


hello = "Hell'o"
world = 'World"'
i = 12
hw12 = F'{hello:s} {world} {i:d}'# string formatting using f-strings
hw12


s = "hello"
print(s.capitalize())  # Capitalize a string
print(s.upper())       # Convert a string to uppercase; prints "HELLO"
print(s.rjust(7))      # Right-justify a string, padding with spaces
print(s.center(7))     # Center a string, padding with spaces
print(s.replace('l', '(ell)'))  # Replace all instances of one substring with another


 # a jupyter notebook feature, not python
s.upper?


help(s.upper) # Some as s.upper? but a python feature


dir(s) # List all the functions available on a string object


x = 1
print("1. Type of x = ", type(x))
x = "str"
print("2. Type of x = ", type(x))


lst = [1, 2, 3, 4, 5]
print(lst)


lst[0]


xs = [1, 2, 3, 'hello', [4, 5, 6]]    # Create a list
print(xs)
print('First element of the array: ', xs[0])  # Index to the list starts with 0
print('Last element of the array: ', xs[4])
print(xs[4][1])


# Negative indices count from the end of the list; 
print(xs[-1])     # Index -1 returns the last item in the list
print(xs[-2])     # Index -2 returns the second item from the end of the list


xs[2] = 'foo'    # Lists can contain elements of different types
print(xs)


xs.append('bar') # Add a new element to the end of the list
print(xs)


print(xs)
x = xs.pop()     # Remove and return the last element of the list
print(x)
print(xs)


xs.insert(1, "new item") # Insert the "new item" at the index 1
print(xs)


xs.remove("foo") # Removing an item by value
print(xs)


colors = ["Red", "Green", "White", "Black"]
# Print the first color in the above list
print(colors[0])
# Print the last color in the above list
print(colors[-1])
# Append "Blue" to the above list
colors.append('Blue')
print(colors)
# Remove "Green" from the above list
colors.remove('Green')
print(colors)


colors = ["Red", "Green", "White", "Black"]
colors2 = sorted(colors)
colors2, colors


colors.sort()
colors


# nums = range(5) # Python 2, but error in Python 3
nums = list(range(5))    # range is a built-in function that creates a list of integers
nums = [0, 1, 2, 3, 4]
print(nums)         # Prints "[0, 1, 2, 3, 4]"
print(nums[2:4])    # Get a slice from index 2 to 4 (exclusive); prints "[2, 3]"
print(nums[2:])     # Get a slice from index 2 to the end; prints "[2, 3, 4]"
print(nums[:2])     # Get a slice from the start to index 2 (exclusive); prints "[0, 1]"
print(nums[:])      # Get a slice of the whole list; prints ["0, 1, 2, 3, 4]"
print(nums[::-1])    # Slice indices can be negative; prints ["0, 1, 2, 3]"
nums[2:4] = [8, 9]  # Assign a new sublist to a slice
print(nums)         # Prints "[0, 1, 8, 9, 4]"


lst = list(range(0,100,10))
print(lst)


# Print everything except the last three elements
print(lst[:-3])


# Print everything with odd indices
print(lst[::2])


# Print everything with even indices
print(lst[1::2])


# Print everything in reversed order
print(lst[::-1])


A = list(range(1,10,1)) # start,stop,step
print(A)


# YOUR CODE HERE
raise NotImplementedError()


# Last cell should output length of the list `colors`


animals = ['cat', 'dog', 'monkey']
for animal in animals:
  print(animal)


for i in range(1, 21):
  print(f"{i:d}^2 = {i*i:d}")


nums = [0, 1, 2, 3, 4]
squares = []
for x in nums: # Don't forget the colon
    squares.append(x ** 2)
print(squares)


nums = [0, 1, 2, 3, 4]
squares = [x ** 2 for x in nums]
print(squares)


nums = [0, 1, 2, 3, 4]
even_squares = [x ** 2 for x in nums if (x % 2 == 0 and x <=2)]
print(even_squares)

def sq(x): return x**2
list(map(sq, nums))

def even(x): return (x % 2 == 0 and x <=2)
list(map(sq, filter(even, nums)))

[0, 4]

[0, 4]


d = {'cat': 'cute', 
     'dog': 'furry'}  # Create a new dictionary with some data
print(d['cat'])       # Get an entry from a dictionary; prints "cute"
key = 'cat'
print(d[key])
print('cat' in d)     # Check if a dictionary has a given key; prints "True"

cute
cute
True


d['fish'] = 'wet'    # Set an entry in a dictionary
print(d['fish'])     # Prints "wet"

d['elephant'] = 'heavy'  # Set an entry in a dictionary
print(d['elephant'])     # Prints "heavy"


for key, value in d.items():
  print('key = ', key, '\t value = ', value)


for key in d.keys():
  print('key = ', key, '\tvalue = ', d[key])


for key in sorted(d.keys()):  # sorting the key
  print('key = ', key, '\t\tvalue = ', d[key])


for value in sorted(d.values()):  # print all values
  print('value = ', value)


print('monkey' in d)

# print(d['monkey'])  # KeyError: 'monkey' not a key of d


print(d.get('monkey', 'N/A'))  # Get an element with a default; prints "N/A"
print(d.get('fish', 'N/A'))    # Get an element with a default; prints "wet"


del d['fish']        # Remove an element from a dictionary

# Be aware that the deleted key-value pair is removed permanently.
print(d.get('fish', 'N/A')) # "fish" is no longer a key; prints "N/A"


d = {'person': 2, 'cat': 4, 'spider': 8}
for animal, legs in d.items():
    print('A {} has {} legs'.format(animal, legs))


nums = [0, 1, 2, 3, 4]
even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0}
print(even_num_to_square)

def sq(x): return (x, x**2)
def even(x): return x%2 == 0
dict(map(sq, filter(even, nums)))

{0: 0, 2: 4, 4: 16}


dimensions = 800, 600
print(dimensions[0])
print(dimensions[1])

squares = (x**2 for x in range(10))
squares

800
600

<generator object <genexpr> at 0x7ffabc4bf200>


dimensions = 800, 600
print(dimensions[0])
print(dimensions[1])


# Try this (uncomment)
# dimensions[0] = 1000  # this will return error


d = {(x, x + 1): x for x in range(10)}  # Create a dictionary with tuple keys
t = (5, 6)       # Create a tuple
print(type(t))
print(d[t])       
print(d[(1, 2)])


x, *rest = 1, 3, 4
print(x, rest)

1 [3, 4]


x, y, z = [1, 2, 3] # Lists can be used for Multiple assignment 
print(x, y, z)


x, y, *rest = range(10) # Lists can be used for Multiple assignment 
x, y, rest


x, y, z = 1, 2, 3  # Tuples can be used for Multiple assignment 
print(x, y, z)


fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x)


for x in "banana": # string is also a sequence type
  print(x)


fruits = ["apple", "banana", "cherry"]
for x in fruits:
  if x == "banana":
    break
  print(x)


fruits = ["apple", "banana", "cherry"]
for x in fruits:
  if x == "banana":
    continue
  print(x)


# Shows while loop. Do not use this style though, prefer for loop. 
# This style is considered not Pythonic
# https://peps.python.org/pep-0008/
idx = 0
while (idx < len(fruits)):
  print(fruits[idx])
  idx += 1


age = 19
if age >= 18:
  print("You are old enough to vote!")
elif (age <= 27):
  pass
else:
  print("Sorry, you are too young to vote.")


age = 12
if age < 4:
  price = 0
elif age < 18:
  price = 25
else:
  price = 40

print(f"Your admission cost is ${price}.")


# Making the argument b and c optional with 4 and 8 as default values
def sum2(a, b=4, c=8): 
  return a + b + c, a*b*c # Returns a tuple of two values


sum2(1, c=5)

(10, 20)


sum_, prod_ = sum2(1, c=5) # Unpacking a tuple


prod_

20


def sign(x, y=100):
  if x > 0:
    return 'positive', 123
  elif x < 0:
    return 'negative', 123
  else:
    return 'zero', 123

for x in [-1, 0, 1]:
  v1, _ = sign(x)
  print(v1)


def hello(name, loud=False):
    if loud:
        print('HELLO, {}'.format(name.upper()))
    else:
        print('Hello, {}!'.format(name))

hello('Bob')
hello('Fred', loud=True)


def fun(list_):
  list_.append('new item')

a = [1, 2, 3]
fun(a)
print(a)


def fun(lst):
  lst.append('new item')

a = [1, 2, 3]
# Preventing a Function from Modifying a List
fun(a[:]) # The slice notation [:] makes a copy of the list
# fun(a.copy()) 
print(a)


# Global Namespaces
# Global scope
X = 99 # X and func assigned in module: global
#print(globals())

def func(Y): # Y and Z assigned in function: locals
  # Local scope
  X = 3
  Z = 0
  def funcfunc(Y2):
      if True:
          nonlocal Z
          Z = X + Y2 # X is a global
          for i in range(10):
                if True:
                    W = 0
      print("funcfunc", locals())
      return Z
  funcfunc(Y)
  print("func", locals())
  return Z

func(1) # func in module: result=100

funcfunc {'Y2': 1, 'i': 9, 'W': 0, 'X': 3, 'Z': 4}
func {'Y': 1, 'funcfunc': <function func.<locals>.funcfunc at 0x7ffabc4229d0>, 'X': 3, 'Z': 4}

4


X = 99 # Global scope name: not used

def f1():
  X = 88 # Enclosing def local
  def f2():
    print(X) # Reference made in nested def
  f2()

f1() # Prints 88: enclosing def local
print(X)


X = 99 # Global X

def func():
  X = 88 # Local X: hides global

func()
print(X) # Prints Global X 99: unchanged


X = 99 # Global X

def func():
  global X
  X = 88 # Local X: overrides global

func()
print(X) # Prints 88: unchanged


def func():
    for x in range(100):
        pass

# what is x
x = 1
def func(x, y=[1, 2, 3]):
    y.append(4)
    print(y)
    
func(1)
func(1)
func(1)

[1, 2, 3, 4]
[1, 2, 3, 4, 4]
[1, 2, 3, 4, 4, 4]


x = 0
for i in range(100):
    if i % 23 == 0:
        x = 23
    else:
        x = 1
# what is x?
x


x = 0
def foo():
    for i in range(100):
        if i % 23 == 0:
            x = 23
        else:
            x = 1
# what is x?
x


x = 2; z = sqrt(x)
assert abs(z*z - x) < 1e-8
x = 3; z = sqrt(x)
assert abs(z*z - x) < 1e-8
x = 4; z = sqrt(x)
assert abs(z*z - x) < 1e-8
import random
for _ in range(10):
    x = random.randint(1, 100); z = sqrt(x)
    assert abs(z*z - x) < 1e-6
'success'


3 * 5


3 ** 5


# Using * to unpack iterables into a list/tuple
numbers = [2, 1, 3, 4, 7]
more_numbers = [*numbers, 11, 18]
print(*more_numbers, sep=', ')

first, *rest = [*numbers, 11, 18]
print(rest, sep=', ')


# Unpack a dictionary
date_info = {'ye ar': "2020", 'month': "01", 'day': "01"}
filename = "{ye ar}-{month}-{day}.txt".format(**date_info)
print(filename)

def func(**kwargs):
     return "{ye ar}-{month}-{day}.txt".format(**kwargs)
func(**date_info)

2020-01-01.txt

'2020-01-01.txt'


languages = ['Java', 'Python', 'JavaScript']
versions = [14, 3, 6]

result = list(zip(languages, versions))
print(result)


list(zip(*result))


mat = [[1, 2, 3],
        [4, 5, 6]]
mat_transpose = list(zip(*mat))
print(mat_transpose)
print(list(zip(*mat_transpose)))


for (x, y) in zip(languages, versions): # pairs of items pulled from  two lists
  print(x, y)


keys = ['spam', 'eggs', 'toast']
vals = [1, 3, 5]

D2 = {}
for (k, v) in zip(keys, vals): 
  D2[k] = v

D2


T1, T2, T3 = (1,2,3), (4,5,6), (7,8,9)
list(zip(T1, T2, T3))


coordinate = ['x', 'y', 'z']
value = [3, 4, 5]

result = zip(coordinate, value)
result_list = list(result)
print(result_list)

c, v =  zip(*result_list)
print('c =', c)
print('v =', v)


class Date:
    default_year = 1000
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day
        
    def days(self):
        return (self.year  -2000)* 360 + self.month * 30 + self.day
    
    
today = Date(2023, 1, 26)
print(today.days())

class Addition: 
    # first = 0
    # second = 0
    answer = 0 # Class member
    
    # parameterized constructor 
    def __init__(self, first, second): 
        self.first = first 
        self.second = second 

    def display(self): 
        print("First number = " + str(self.first)) 
        print("Second number = " + str(self.second)) 
        print("Addition of two numbers = " + str(self.answer)) 

    def calculate(self): 
        self.answer = self.first + self.second 
    
# creating object of the class 
# this will invoke parameterized constructor 
obj = Addition(1000, 2000) 

# perform Addition 
obj.calculate() 

# display result 
obj.display()

8336


class Person:

    # Constructor
    def __init__(self, name):
        self.name = name  # Create an instance variable

    # Instance method
    def getName(self):
        return self.name 

    # To check if this person is an employee 
    def isEmployee(self): 
        return False

# Making an instance from a class
g = Person('Fred')  # Construct an instance of the Greeter class

# Accessing attributes
print(g.name)

# Calling methods
print(g.getName())


class A(object):

    @staticmethod
    def stat_meth():
        print("Look no self was passed")

a = A()
a.stat_meth()


# Inherited or Subclass (Note Person in bracket) 
class Employee(Person): 
   
    # Constructor
    def __init__(self, name, year):
        self.years = year  # Create an instance variable
        super().__init__(name)

    # Overriding Methods from the Parent Class
    def isEmployee(self): 
        return True
   
# Driver code 
emp = Person("Geek1")  # An Object of Person 
print(emp.getName(), emp.isEmployee()) 
   
emp = Employee("Geek2", 20) # An Object of Employee 
print(emp.getName(), emp.isEmployee())


mytuple = ("apple", "banana", "cherry")
myit = iter(mytuple) # define

print(next(myit)) # apple
print(next(myit)) # banana
print(next(myit)) # cherry
# Try this (uncomment)
# print(next(myit)) # raises StopIteration exception (not all exceptions are errors)


mystr = "banana"
myit = iter(mystr)

print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))


mytuple = ("apple", "banana", "cherry")
i = 0
while (i < len(mytuple)): 
    print(mytuple[i])
    i += 1


mytuple = ("apple", "banana", "cherry")

print(mytuple)

for idx, val in enumerate(mytuple):
  print(idx, val)


mytuple = ("apple", "banana", "cherry")

print(mytuple)

for val in mytuple:
  print(val)


mystr = "banana"

for x in mystr:
  print(x)


# Iterating over dictionary 
d = dict()  
d['xyz'] = 123
d['abc'] = 345
for i in d : 
    # print("%s  %d" %(i, d[i]))
    print("{}\t{}".format(i, d[i]))


class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    x = self.a
    self.a += 1
    return x

myinstance = MyNumbers()
myiter = iter(myinstance)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))


class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    if self.a <= 10:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
  print(x)


# Two separate lists 
thing = ["Apple", "Audi", "Pasta", "dog", "UMAINE"] 
category = ["fruit", "car",  "food", "animal"] 
  
# Combining lists and printing 
for t, c in zip(thing, category): 
    print("{} is {}".format(t, c))


l1,l2 = zip(*[('Apple', 'fruit'),  
              ('Audi', 'car'),  
              ('Pasta', 'food')  
           ]) 
  
# Printing unzipped lists       
print(l1) 
print(l2)


def simpleGeneratorFun(): 
    x = 5
    # print(x)
    yield 1 + x

    x = 2*x
    #print(x)
    yield 1 + x

    
    x = 2*x
    #print(x)
    yield 1 + x


simpleGeneratorFun()


x = simpleGeneratorFun()
next(x)


list(simpleGeneratorFun())


def nextSquare(): 
    i = 1; 
  
    # An Infinite loop to generate squares  
    while True: 
        yield i*i                 
        i += 1  # Next execution resumes  
                # from this point      
  
# Driver code to test above generator  
# function 
for num in nextSquare(): 
    if num > 100: 
         break    
    print(num)


# Packages are stored on PyPi servers by default and can be directly installed from github as well.
!pip install --user import-ipynb


import import_ipynb


%%writefile myModule.py

s = "hi from my module"


# YOUR CODE HERE
raise NotImplementedError()


import sys
import os

dirpath = os.getcwd()
print("current directory is : " + dirpath)
foldername = os.path.basename(dirpath)
print("Directory name is : " + foldername)


!mkdir -p my_module


%%writefile my_module/__init__.py
""" My module is the best module ever. """
def identity(x):
    """ This function always returns what it is given """
    return x


import my_module
help(my_module)


!cp myModule.py my_module


import my_module.myModule as mmmm
mmmm.s

Traceback (most recent call last):

  File "/tmp/ipykernel_28792/254229001.py", line 1, in <module>
    import my_module.myModule as mmmm

ModuleNotFoundError: No module named 'my_module'


def of(self):
    print(self)
    return "f"
class MyClass:
    f = of
    def g():
        return "g"
    
    @staticmethod
    def h():
        return "h"
    
    @classmethod
    def i(cls):
        print(cls)

MyClass().h()
MyClass().f()
MyClass().i()

<__main__.MyClass object at 0x7ffabc4378b0>
<class '__main__.MyClass'>

Introduction¶

Differences between C and Python¶

Hello world in Python¶

Builin data types¶

Numerics¶

Sequences¶

Mappings¶

Numbers¶

Differences from C¶

Booleans¶

NoneType¶

Sequences¶

Strings¶

Difference from C¶

Slicing¶

Loops¶

Differences from C¶

Exercise 9¶

List comprehensions:¶

Dictionaries¶

Tuples¶

Flow Control¶

Differences from C¶

Truth value testing¶

Functions¶

Variable Scope¶

Exercise : Implement a sqrt function¶

Asterisks in Python¶

zip¶

Classes¶

Defining a Class¶

Inheritance¶

Iterators¶

An iterator is an object that can be iterated upon, meaning that you can traverse through all the values.¶

Strings, lists, tuples, dictionaries, and sets are all iterable objects.¶

Looping Through an Iterator¶

Create an Iterator¶

zip function¶

yield vs return¶

Modules and Packages¶

Read More¶