'''
# Chap 2: Working with Data
https://dabeaz-course.github.io/practical-python/Notes/02_Working_with_data/00_Overview.html
2.1 Datatypes and Data Structures
2.2 Containers
2.3 Formatted Output
2.4 Sequences
2.5 Collections module
2.6 List comprehensions
2.7 Object model

'''
        ##### 2.1 Datatypes and Data structures
        #####

## none type: None is often used as a placeholder for optional or missing value. It evaluates as False in conditionals.
email_addr = None

    ## Tuples   ()- collection of values grouped together. represent simple records or structures.
    ## A good analogy: A tuple is like a single row in a database table.
    ## Contents are ordered but can not be modified. It is read only

s = ('GOOG', 100,440.23)
s1 = 'YAHO',88,212.12   # is also tuple type and bracket is optional
s2 = ()     # an empty tuple
print(s[2])

    # Tuple packing -- like swift programming lang; related items are packed together in a single entity.
    # this is then passed to function or returned from function.
s = ('Id',22,'F')   # id, age and gender can be packed together
print(s)

# Tuple unpacking -- tuple elements can be unpacked to use it elsewhere
id,age,gender = s   
print(id,age,gender)

    ## Dictionaries { } -- key value mapping
    ##
s = { 'id':'Id11',
      'age':22,
      'Gender': 'F'
    }

print(s['id'])

# excercise using tuple, reading csv file
import os
import csv

fpath = os.getcwd()
fpath += r'\work\data\portfolio.csv'
with open(fpath,'rt') as f:
    rows =csv.reader(f)
    hdr =next(rows)
    print(hdr)
    r = next(rows)
    print(r)
    (a,b,c)  = next(rows)    
    print(a,b,c)
    for row in rows:
        (a,b,c) = row
        print((a,b,c))        
        print("---" + row[0],row[1])

# iterate throught dict items
dict1 = s
items = dict1.items()
print(items)
for i in dict1:
    print(i, dict1[i])


'''
######  2.2 Containers
==============
Lists. Ordered data.
Dictionaries. Unordered data.
Sets. Unordered collection of unique items.
'''
# list of tuples
portfolio = [
    ('GOOG', 100, 490.1),
    ('IBM', 50, 91.3),
    ('CAT', 150, 83.44)
]
# list of dictionaries
portfolio2 = [
    {'name': 'GOOG', 'shares' :100, 'price':490.1},
    {'name': 'IBM', 'shares' :50, 'price':90.1},
    {'name': 'CAT', 'shares' :150, 'price':49.1},    
]
x1 = []
x1.append("one")
len(x1)
print(x1)
#dict

priceList = []  # list 
priceDict = {}  #dict
def prices_ex():
    import os
    import csv
    fpath = os.getcwd()
    fpath += r'\work\data\prices.csv'
    with open(fpath,'rt') as f:        
        for line in f:
            xm = line.split(',')
            if len(xm) >=2:            
                priceList.append([xm[0],float(xm[1])])                
                priceDict[xm[0]] = float(xm[1])        
    print(priceList)
    print(priceDict)    
prices_ex()
for d in priceDict:
    print(d,priceDict.get(d))

print(priceDict.get('IBM',0.0))

## Sets  {} -Sets are collection of unordered ---unique--- items.
## Sets are useful for membership tests.
## Sets are also useful for duplicate elimination.
tech_books = {'abc', 'def', 'ghi','ghi'}
tech_stock = set([123,423,121])
tech_stock
123 in tech_stock

'''
                #######  2.3 Formatting
f-string -- The part {expression:format} is replaced.
Format codes (after the : inside the {}) are similar to C printf(). Common codes include:
d       Decimal integer
b       Binary integer
x       Hexadecimal integer
f       Float as [-]m.dddddd
e       Float as [-]m.dddddde+-xx
g       Float, but selective use of E notation
s       String
c       Character (from integer)
'''
name = 'ibm'
shares = 100
price =91.11777
xf1 = f'{name:>10s}{shares:>10d} {price:>10.2f}'
print(xf1)

s = {       #dict
    'name': 'IBM',
    'shares': 100,
    'price': 91.1
}
'{name:>10s} {shares:10d} {price:10.2f}'.format_map(s)
## using format method

## C-Style formatting
print('price of apple in fruticana is %d cent' %99)     ##note there is no ' ,' and there is % to fetch value
print('price of %s in fruticana is %f %s' %('apple', 99.9, 'cent'))

## f format doc https://docs.python.org/3/library/string.html#format-specification-mini-language
value = 4323.1004
print(f'{value:0.4f}')
print(f'{value:2.2f}')
print(f'{value:12.2f}')
print(f'{value:>12.2f}')
print(f'{value:<12.2f}')
print(f'{value:$^12.2f}')
print(f'{value:$>12.2f}')

'''
2.4 Sequences: Python has three Seq data types - 
    String  ''
    List    []
    Tuple   ()
 > All sequences are ordered, indexed by integers, and have a length.
 > Sequences can be replicated: s * n.
 > Sequences of the same type can be concatenated: s + t.
 > Slicing of a sequence - s[start:end]
'''

## Exercise 2.13: Counting
### range(): looping over sequence 
for i in range(10,20):
    print(i)

for n in range(10,0,-1):       # Count 10 ... 1
        print(n, end=' ')

for i in range(0,10,1):       # Count 10 ... 1
        print(i, end=' ')

### enumerating over sequence --> enumerates into tuple
names = ['aa','bx','dfds','zee']
for i,val in enumerate(names):
    print(i,val)

for i in enumerate(names):
    print(i)
    print(type(i))
    #type(i)
    lst=list(i)
    print(lst, type(lst))
    tu = tuple(i)
    print(tu, type(tu))
    dct = {}
    dct[i[0]] = i[1]
    print(dct, type(dct))

### zip() function
# combines multiple sequences and makes an iterator that combines them
names = ['aa','bx','dfds','zee']
price = [22.22,43.53,6436.77,45.34]

shares = zip(names,price)                   # cobines and results in iterator
shares_list = list(zip(names,price))        #converts zip list iterator to list
for col,val in shares:
    print(col,val)

# Exercise 2.15: A practical enumerate() example
'''
Recall that the file Data/missing.csv contains data for a stock portfolio, but has some rows with missing data. 
Using enumerate(), modify your pcost.py program so that it prints a line number with the warning message when it 
encounters bad input.
'''
import os
import csv
workdir = os.getcwd()
workdir += r'\work\data'
with open(workdir+r'\missing.csv','rt') as f:
     rows = csv.reader(f)
     for i,row in enumerate(rows):
          try:
            for val in row:
                 if len(val) <= 0:
                    raise ValueError                                
            print(i, ' ', row, ' ')
          except ValueError:
               print(f'## Row {i}: Bad row:{row}')

##Exercise 2.16: Using the zip() function
'''
'''
import os
import csv
workdir = os.getcwd()
workdir += r'\work\data'
holding =[]
zholding=[]
hdr = ['name','shares', 'price','current price', 'purchase cost', 'current cost','gain/loss']
with open(workdir +r'\portfolio.csv','rt') as f, open(workdir +r'\prices.csv','rt') as g:
    rows = csv.reader(f)
    header = next(rows)    
    for i,row in enumerate(rows):                
        print(f'i={i} " " {row}')
        g.seek(0)
        prices = csv.reader(g)
        for item in prices:
           # print(item)
            #strx = item.split(',')
           # print("strx =", strx)
            if row[0] == item[0]:
                #print('******match', row[0] ,item[0])                
                status = row                
                cur_price = float(item[1])
                pur_cost = float(row[1])* float(row[2])
                cur_cost = float(row[1])* float(cur_price)
                gain_loss = cur_cost - pur_cost
                temp = [cur_price,pur_cost,cur_cost,gain_loss]
                status += temp
                print('--> in')
                zst = list(zip(hdr, status))
                zholding.append(zst)
                holding.append(status)
                break
    

print("#------------Report -----------------#\n")
print(hdr)
for i, share in enumerate(holding):    
        print( f'{i} {share}\n')

print("#------------Report2 -----------------#\n")
print(hdr)
for i, share in enumerate(zholding):    
        print( f'{i} {share}\n')


## Exercise 2.17: Inverting a dictionary using zip()
##Note-- When used in comparisons, tuples are compared element-by-element starting with the first item.
##    -- zip() is often used in situations like this where you need to pair up data from different places. 
##      -- Also, be aware that zip() stops once the shortest input sequence is exhausted.

prices = {
        'GO':55,
        'MS':33,
        'fb':66
}

# to get list of value key
price_list = list(zip(prices.values(),prices.keys()))
price_list
v,k = price_list[0]
print(sorted(price_list))
a = [1, 2, 3, 4]
b = ['w', 'x', 'y', 'z']
c = [0.2, 0.4, 0.6]
list(zip(a, b, c))


'''##                             ##'''
##        2.5 collections module    ##
'''##                             ##'''

# tabulate total shares of each stock

portfolio = [
    ('GOOG', 100, 490.1),
    ('GOOG', 120, 390.1),
    ('IBM', 50, 91.3),
    ('CAT', 150, 83.44),
    ('GE', 150, 83.44),
    ('GE', 100, 76.44),
    ('GOOG', 67, 290.1)
]

# use counter() object from collections module
from collections import Counter
total_shares = Counter()
for name,shares,price in portfolio:
    total_shares[name] +=shares

total_shares['GE']

# using defaultdict


'''##                             
##       2.6 List Comprehensions    ##
[ <expression> for <variable_name> in <sequence> if <condition>]
#A common task is processing items in a list. This section introduces list comprehensions, a powerful tool for doing just that.
'''##                            

# A list comprehension creates a new list by applying an operation to each element of a sequence
#Creating new lists
a = [1,2,3,4,5 , -10,22,12,6]
b = [2*x for x in a]
b

nameX = [nm.upper() for nm in names]
nameX

#Filtering
xt = [print(x) for x in a if x>0]
xt

## first run report.py program in bash/powershell mode and then try 


## set comprehennsion
## using { } bracket for this
xt = { print(s) for s in zholding}
xt = { print(s) for s in holding}
xt


'''##                             
##       2.6 Objects    ##

'''##   
# Assignment
# assignment operations never make a copy of the value being assigned. 
# All assignments are merely ****reference copies**** (shallow copy or copy by reference or * assignment) (or pointer copies if you prefer).
# to check the two assigned values; use "is" or "==" to compare eg: a is b or a == b
## shallow copy
a = [2,3,4]
b =a
b
a.append(5)
a
b
b.append(0)
a
b
c = b
b[1] == a[1]
# Reassigning values
# Reassigning a value never overwrites the memory used by the previous value.
a = [9,9,9,9]
a
b
a is b      # compares not the value by the pointer/reference address

id(a) == id(b)
id(a)
id(b)
id(c)

## deep copy
# use copy module
import copy
a = [2,4,[55,66]]
b = a
a
b
a == b
a[2].append(99)
a
b

b = copy.deepcopy(a)
a
b
a == b
a[2].append(100)
a
b
a[2] == b[2]

## Type Checking for an object -- isinstance()
a = [2,3,4]
type(a)
isinstance(a, list)
'''
Everything is an object
Numbers, strings, lists, functions, exceptions, classes, instances, etc. are all objects. 
It means that all objects that can be named can be passed around as data, placed in containers, etc., 
without any restrictions. There are no special kinds of objects. Sometimes it is said that all objects are “first-class”.
'''
import math
import os
items = [abs, math, copy, os, ValueError, 1, "strd", {"age":23}, (32,4)]
items

'''
Exercise 2.24: First-class Data
'''
import os
import csv
workdir = os.getcwd()
workdir += r'\work'
types =[str,int,float]
with open(workdir+r'\data\portfolio.csv') as f:
    rows = csv.reader(f)
    hdr = next(rows)    
    shareValue =0
    for row in rows:       
       r = zip(types,row)
       print(list(r))
       shareValue += types[1](row[1])*types[2](row[2])
    print(f'total share value = {shareValue}')

##2 -- more useful to pase data; use types and then use zip. new thing is using "fun" function type
types =[str,int,float]
with open(workdir+r'\data\portfolio.csv','rt') as f:
    rows = csv.reader(f)
    hdr = next(rows)    
    shareValue =0
    shareValue2 =0
    allData = []
    dataDict = []
    for row in rows:       
        converted = []
        for fun, val in zip(types,row):     #In the loop, the func variable is one of the type conversion functions       
           converted.append(fun(val))       # this can also be done wtih - { name: func(val) for name, func, val in zip(headers, types, row) }        
        shareValue2 += converted[1]*converted[2]
        d= dict(zip(hdr,converted))
        dataDict.append(d)
        allData.append(converted)
        shareValue += types[1](row[1])*types[2](row[2])
    print(f'total share value = {shareValue}  {shareValue2}')       

for x in allData:
    print(x)

##2 - using list comprehension to do similar 
f = open(workdir+r'\data\dowstocks.csv','rt')
rows =csv.reader(f)
hdr = next(rows)
types = [str, float, str, str, float, float, float, float, int]
for row in rows:
    convertedX= [fun(val) for fun,val in zip(types,row)]
f.close()