# Print the philosophy of Python
import this

!echo $SHELL

!uname -a

!id

!python3 --version

!ls

!pwd

!mkdir test

# Let us not forget our real home location so that we can
# comeback to it
if not 'workbookDir' in globals(): # check if the variable exists
    import os
    workbookDir = os.getcwd() # save the CWD (current working directory) to a variable

# always start in that directory before the next few cells
%cd $workbookDir

!cd test

%pwd

%cd test

%pwd

%alias

%ls --help

%%capture capt
import sys
print('Hello stdout')
print('and stderr', file=sys.stderr)

capt.stdout, capt.stderr

capt.show()

%cd $workbookDir/test
!touch hi.txt
!sleep 1
!touch alive.txt
!sleep 1
!touch bye.txt
%cd $workbookDir

%%capture lsoutput
%cd -q $workbookDir/test
# Write the magic %ls command with the correct flags here
...
%cd -q $workbookDir

lsoutput.show()

# The following test should pass
def test_ls_output(lsoutput):
    expected_output = 'bye.txt  alive.txt  hi.txt'
    assert lsoutput.stdout.strip() == expected_output.strip(), lsoutput.stdout
test_ls_output(lsoutput)

# always start in that directory before the next few cells
%cd $workbookDir

%%writefile helloworld.c
#include <stdio.h>
int main() {
  printf("hello world from C!\n");
}

!gcc helloworld.c -o helloworld && ./helloworld

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2] # Split arr in half
    left = [x for x in arr if x < pivot] # Take elements smaller than pivot
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot] # Take elements greater than pivot
    return quicksort(left) + middle + quicksort(right) # Concatenate lists

print(quicksort([3,6,8,10,1,2,1]))

print("hello world from Python!")

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

!python3 helloworld.py

%%writefile helloworld_main.py
def foo():
    print("Function foo was called")

print("Inside the script ", __name__)
if __name__ == '__main__':
    print("Hello world from __name___ == '__main__' condition")

!python3 helloworld_main.py

import helloworld_main

"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 be printed

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

import sys
sys.float_info # Prints the system's default float size

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)

y = 2.5
print(type(y))
print(y, y + 1, y * 2, y ** 2)

import math
def value2binary(n, base=2):
    """
    Find binary representation of n by repeated division
    """
    bits = []
    ncopy = n
    while ncopy > 0:
        ncopy, remainder = divmod(ncopy, base)
        bits.append(remainder)
    return list(reversed(bits))

value2binary(1024)

def ieee754_exponent(n, expbits=11):
    """
    Find the exponent of n in ieee 754 representation.

    It returns both frac and exp, so that the original number is
    frac x 2^{-exp}
    """
    exp = 0
    if n == 0:
        return (None, 0)
    frac = n
    # Try for maximum number of expbits
    # The basic logic is that if the number is smaller than 1
    # then keep multiplying it by 2 until it becomes bigger than 1
    # and keep a track of how many times we multiplied it by 2
    # as the exponent $e$.
    # Do the same if the number is bigger than 2, but divide it by 2
    for _ in range(expbits-1):
        if 1 <= abs(frac) and abs(frac) < 2:
            break
        elif abs(frac) > 2:
            frac /= 2
            exp += 1
        else: # frac <= 1
            frac *= 2
            exp -= 1
    if abs(frac) < 1: raise ValueError("Number too small")
    if abs(frac) >= 2: raise ValueError("Number too big")
    return exp, frac

ieee754_exponent(0.1)

1.6*(2**(-4))

ieee754_exponent(0.1), ieee754_exponent(0.2), ieee754_exponent(0.3)

ieee754_exponent(0.125), ieee754_exponent(0.25), ieee754_exponent(0.375)

import random
def exponent_frac_to_number(exp, frac):
    return frac * 2**exp

def test_ieee754_exponent():
    for _ in range(100): # do this hundred times
        n = random.random()*200-100 # pick a random number between -100 and 100
        exp, frac = ieee754_exponent(n) # Conversion
        nagain = exponent_frac_to_number(exp, frac) # we should get n back again
        assert abs(nagain - n) < 2**42, f"test failed for {n}, {exp}, {frac}"

test_ieee754_exponent()

x = 0.2 + 0.1
x == 0.3

abs(x - 0.3) < 1e-16

x = 0.25 + 0.125
x == 0.375

%%capture q3output
# Print 0.1 to 5 decimal places
...
# Print 0.1 to 20 decimal places
...

q3output.show()

# The following test should pass
def test_q3output(q3output):
    expected_q3output = """\
0.1 = 0.10000
0.1 = 0.10000000000000000555
"""
    assert q3output.stdout == expected_q3output
test_q3output(q3output)

your_answer = ...

def test_floating_point(your_answer):
    assert abs(0.1+0.2-0.3) <= your_answer

test_floating_point(your_answer)

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

hw12 = hello + world + str(12)
print(hw12)

hw12 = hello + ' ' + world + ' ' + str(3.1415)
print(hw12)

# Yes you can use emojis (unicode support)
f"{hello} 😀 😃 😄 😁 😆 {i:d} emojies"

"\N{GRINNING FACE}"

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

s = 'hello'
s = s.upper()
print(s)

 # 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

print("ECE 491/591\n\tDeep Learning\nis fun!")

print('  w\to\tr  l\nd '.strip())  # Strip leading and trailing whitespace

print('  world '.rstrip())  # Strip trailing whitespace

print('  world '.lstrip())  # Strip leading whitespace

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)

def length_of_colors(colors):
    colors_lengths = ...
    return colors_length

def test_length_of_colors(length_of_colors):
    import random
    n = random.randint(1, 100)
    colors = ['red'] * n
    assert n == len(colors)
test_length_of_colors(length_of_colors)

# Last cell should output length of the list `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)

def ele_7th_to_3rd_list(A):
    slice_7th_to_3rd = ...
    return slice_7th_to_3rd
ele_7th_to_3rd_list(A)

# 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}")

animals = ['cat', 'dog', 'monkey']
for idx, animal in enumerate(animals):
    print('#{}: {}'.format(idx, animal))

# Fibonacci series
FIB20 = [] # modify the list to contain fibonacci using a for loop
...
print(FIB20)

assert len(FIB20) == 20
assert FIB20[0] == 0
assert FIB20[1] == 1

assert FIB20 == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181]

a = [1, 2, 3, 4, 5]
b = a[:]  # copying the list
# b = a.copy() # <- preferred way
c = a     # This doesn't copy the list!

a.append('x') # a = [1, 2, 3, 4, 5, 'x']
b.append('y') # b = [1, 2, 3, 4, 5, 'y']
c.append('z') # c = [1, 2, 3, 4, 5, 'x', 'z']

print('a = ', a)
print('b = ', b)
print('c = ', c)
print('a = ', a)

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]
def sq(x): return x*x
squares = list(map(sq, nums))
print(squares)

nums = [0, 1, 2, 3, 4]
def filter_cond(x):
    return (x % 2 == 0 and x <=2)
even_squares = list(map(sq, filter(filter_cond,nums)))
print(even_squares)

hash('dog') % 1

d = {'cat': 'cute', # { key : value, }
     '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"

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)

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

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)])

dimensionx, dimensiony = dimensions

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!")
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)

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

prod_

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)

def first_last(a):
    fst_last = ...
    return fst_last

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

X = 99
def func():
    # new variable
    X = 88
    def func1():
        def func2():
            # new variable
            nonlocal X
            X = 66
        func2()
    func1()
    print(X)
func()

# Global scope
X = 99 # X and func assigned in module: global

def func(Y): # Y and Z assigned in function: locals
  global X
  X = 11
  # Local scope
  Z = X + Y # X is a global
  print("Local X", X)
  for i in range(10):
    z = 8
  if True:
    flag = 'true'
  print(flag)
  return Z

func(1) # func in module: result=100
print("Global X", X)

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

for x in range(100):
    pass

# what is x
x

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

def sqrt(x, threshold=1e-8):
    assert x >= 0 # throws an error if x is negative
    ...

sqrt(2)

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 = {'year': "2020", 'month': "01", 'day': "01"}
filename = "{year}-{month}-{day}.txt".format(**date_info)
print(filename)

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:
    def __init__(self, year, month):
        self.year = year
        self.month = month
    def length(self):
        return self.year * 365 + self.month * 30 # convert date to some form of length
date = Date(1996, 10)
date.length() # No repeated calling to to access the function and as an argument to the function

class Addition:
    # first = 0
    # second = 0
    answer = 0 # Class member

    # parameterized constructor
    def __init__(self, first, second):
        self.first = first
        self.second = second

    def calculate(self):
        self.answer = self.first + self.second

# creating object of the class
# this will invoke parameterized constructor
Add = Addition
obj = Add(1000, 2000)

# closures (inside out classes where functionwraps the class data)
def counter(count_init):
    counter = count_init
    def increment(inc):
        nonlocal counter
        counter = counter + inc
        return counter
    return increment

c_inc = counter(0)
c_inc(5)
c_inc(3)

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 Person 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)
thing = ["Apple", "Audi", "Pasta", "dog", "UMAINE"]
category = ["fruit", "car",  "food", "animal"]

zipped = zip(thing, category)
zipped_l = list(zipped)
print(zipped_l)
print(list(zip(zipped_l[0], zipped_l[1], zipped_l[2], zipped_l[3])))

# 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())

# Driver code to check above generator function
# simpleGeneratorFun()
list(simpleGeneratorFun())

#for value in simpleGeneratorFun():
#    print(value)

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 import-ipynb

import import_ipynb

%%writefile myModule.py

s = "hi from my module"

import myModule

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