import random             #imports random library, i will use for generation random numers

import csv                 # improts csv library, used to load my deck of tarrot cards means are taken from http://www.daily-tarot-girl.com/tarot-card-meanings/list-of-tarot-card-meanings/ 

import numpy as np             # imports numpy library and gives it the shorthand np, I will be using std to calulate the standard deviation of my results

import matplotlib.pyplot as plt     # imports matplotlib a tool for plotting grapths in this case barcharts  and histograms

from collections import Counter     # imports counter from collections, will use counter to measure the frequency of the same results produced in various sample sizes




f = open('Tarot.csv', 'r')  # open the file in read mode
data = csv.reader(f)     #reads the data in to a list named data
data = [row for row in data]    # creates a list the entries by each row in the data
f.close()    # closes file to save memory

Freq = []
sets = []

class Tarot():

    """
    A class to make a virtual Tarot deck.

    Atributes:
    a: the number of the card in the deck
    name: the name of the Tarot card associated with the card number
    meaning: the meaning of the card
    """

    def __init__(self, a, name, meaning):  # The init method is a standard method that lets us put arguments into a class for each instance in a list.
        self.a = int(a)
        self.name = name
        self.meaning = meaning


Deck = [Tarot(row[0],row[1], row[2]) for row in data]

def Probs(self, n):
    """
    chooses three Tarot cards for sample size n.

    Arguments:
    n : sample size as the range is set to n+1.

    output: appends all the results to the list sets
    """

    for i in range (1 , n + 1):
        sample = random.sample(Deck, 3)
        for item in sample:
            sets.append(item.a)

def Reading(self):

    """
    Give a three card Tarot reading.

    Arguments n/a

    output: prints the names and the meaning of the three cards drawn
    """
    sample = random.sample(Deck, 3)
    for item in sample:
        print '%s, %s' % (item.name, item.meaning)

Reading(Deck)

Probs(Deck, 1000)

Freq = Counter(sets)

Freq

width = 0.5 # sets the width of the bars in the bar chart
plt.bar(range(len(Freq)), Freq.values(), align = 'center',width = width, color = 'rgbkymc') #
plt.xticks(range(len(Freq)), Freq.keys(), size = 5.5, rotation = 90)
plt.title ('Frequency of Tarot cards draw for sample size of 1000.') # title of graph
plt.xlabel('Card Number') # x-axis label
plt.ylabel('Frequency') # y-axis label
plt.show()
plt.savefig('Frequency.png') # saves the graph as a seperate file

np.std([Freq.values()])

Deviation = [ ]
sets = []
sample_size = []

def std_of_samplesize(self):
    """
    uses probs to find the standard deviation of sample size form 10000 to 500000 in 10000 increments
    
    Arguments: uses the probs def to take sample size of the range and outputs the results into the list sets .
    
    output:
    appends size of the sample to the list sample_size
    takes the list sets and counts the frequency each card is draw
    inputs the standard deviation of the frequency a certain card is draw into list Deviation.
    """

    for i in range(1 , 51):
        Probs(Deck, 10000)
        sample_size.append(10000 * i)
        Freq = Counter(sets)
        Deviation.append(np.std([Freq.values()]))
        

std_of_samplesize(Deck)

sample_size
Deviation

StandardError = [Deviation[i] / sqrt(sample_size[i]) for i in range(len(Deviation))]

StandardError

︠d8d95c21-b90d-470c-b72d-657678b92371︠


x1 = sample_size
y1= StandardError

plt.plot(x1, y1, 'kx')
plt.title ('Graph to show standard sample error.') # title of graph
plt.xlabel('Sample size') # x-axis label
plt.ylabel('Standard Sample Error') # y-axis label
bestfit = np.polyfit(x1, y1, 3)
x2 = np.arange(min(x1) - 100, max(x1) + 100, 5000) #use more points for a smoother plot (i.e creates a line consisting of 5000 points) and extends the range of x1 by the user defined amount.  
y2 = np.polyval(bestfit, x2) #calculates the polynomial for each x2 value, will be used to plot the best fit.
plt.plot(x2, y2, label = "deg=3") # plots the cubic line of best fit
plt.show()
plt.savefig('Longterm.png')