Predictive Analysis

Predictive analysis is the use of statistical, data mining, and machine learning techniques to analyze current and historical data in order to make predictions about future events or behaviors. It involves identifying patterns and trends in data, and then using that information to forecast what is likely to happen in the future.

Predictive analysis is used in a wide range of applications, from forecasting sales and demand, to predicting customer behavior, to detecting fraudulent transactions. It involves collecting and analyzing data from a variety of sources, including historical data, customer data, financial data, and social media data, among others.

The process of predictive analysis typically involves the following steps:

  1. Defining the problem and identifying the relevant data sources
  2. Collecting and cleaning the data
  3. Exploring and analyzing the data to identify patterns and trends
  4. Selecting an appropriate model or algorithm to use for predictions
  5. Training and validating the model using historical data
  6. Using the model to make predictions on new data
  7. Monitoring and evaluating the performance of the model over time

Predictive analysis can help organizations make more informed decisions, improve efficiency, and gain a competitive advantage by leveraging insights from data.

It is most commonly used in Retail, where workers try to predict which products would be most popular and try to advertise those products as much as possible, and also healthcare, where algorithms analyze patterns and reveal prerequisites for diseases and suggest preventive treatment, predict the results of various treatments and choose the best option for each patient individually, and predict disease outbreaks and epidemics.

1. Intro to NumPy and the features it consists

Numpy, by definition, is the fundamental package for scientific in Python which can be used to perform a variety of mathematical operations, provide multidimensional array objects, and makes data analysis much easier. Numpy is very important and useful when it comes to data analysis, as it can easily use its features to complete and perform any mathematical operation, as well as analyze data files.

If you don't already have numpy installed, you can do so using conda install numpy or pip install numpy

Once that is complete, to import numpy in your code, all you must do is:

import numpy as np

2. Using NumPy to create arrays

An array is the central data structure of the NumPy library. They are used as containers which are able to store more than one item at the same time. Using the function np.array is used to create an array, in which you can create multidimensional arrays.

Shown below is how to create a 1D array:

a = np.array([1, 2, 3]) # a is the array name
print(a) 
# this creates a 1D array
[1 2 3]

How could you create a 3D array based on knowing how to make a 1D array?

b = np.array([[[10,20,30,40], [50,60,70,80]]])
print(b)
[[[10 20 30 40]
  [50 60 70 80]]]

Arrays can be printed in different ways, especially a more readable format. As we have seen, arrays are printed in rows and columns, but we can change that by using the reshape function

c = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) # 3 separate arrays, it will reshape it into a single line
print(c.reshape(1, 9)) # organizes it all in a single line of output
[[1 2 3 4 5 6 7 8 9]]

In the code segment below, we can also specially select certain rows and columns from the array to further analyze selective data.

print(c[1:, :2])
# the 1: means "start at row 1 and select all the remaining rows"
# the :2 means "select the first two columns"
[[4 5]
 [7 8]]

3. Basic array operations

One of the most basic operations that can be performed on arrays is arithmetic operations. With numpy, it is very easy to perform arithmetic operations on arrays. You can add, subtract, multiply and divide arrays, just like you would with regular numbers. When performing these operations, numpy applies the operation element-wise, meaning that it performs the operation on each element in the array separately. This makes it easy to perform operations on large amounts of data quickly and efficiently.

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(a + b) # adds each value based on the column the integer is in
print(a - b) # subtracts each value based on the column the integer is in
print(a * b) # multiplies each value based on the column the integer is in
print(a / b) # divides each value based on the column the integer is in
[5 7 9]
[-3 -3 -3]
[ 4 10 18]
[0.25 0.4  0.5 ]
d = np.exp(b) # exponents
e = np.sqrt(b) # square roots
print(d)
print(e)
[ 54.59815003 148.4131591  403.42879349]
[2.         2.23606798 2.44948974]

From the knowledge of how to use more advanced mathematical expressions than the basic 4 mathematical operations such as exponent and square root, now can you code how to calculate the 3 main trig expressions (sin, cos, tan), natural log, and log10 of a 1D array.

f = np.sin(b) # calculate sin
print(f)
g = np.cos(b) # calculate cos
print(b)
h = np.tan(b) # calculate tan
print(h)
i = np.log10(b) # calculate natural log
print(i) 
j = np.log(b) # calculate log10
print(j)
[-0.7568025  -0.95892427 -0.2794155 ]
[4 5 6]
[ 1.15782128 -3.38051501 -0.29100619]
[0.60205999 0.69897    0.77815125]
[1.38629436 1.60943791 1.79175947]

4. Data analysis using numpy

Numpy provides a convenient and powerful way to perform data analysis tasks on large datasets. One of the most common tasks in data analysis is finding the mean, median, and standard deviation of a dataset. Numpy provides functions to perform these operations quickly and easily. The mean function calculates the average value of the data, while the median function calculates the middle value in the data. The standard deviation function calculates how spread out the data is from the mean. Additionally, numpy provides functions to find the minimum and maximum values in the data. These functions are very useful for gaining insight into the properties of large datasets and can be used for a wide range of data analysis tasks.

data = np.array([2, 5, 12, 13, 19])
print(np.mean(data)) # finds the mean of the dataset
print(np.median(data)) # finds the median of the dataset
print(np.std(data)) # finds the standard deviation of the dataset
print(np.min(data)) # finds the min of the dataset
print(np.max(data)) # finds the max of the dataset
10.2
12.0
6.04648658313239
2
19

Now from learning this, can you find a different way from how we can solve the sum or products of a dataset other than how we learned before?

print (np.sum(data))
print(np.prod(data)) 
51
29640

Numpy also has the ability to handle CSV files, which are commonly used to store and exchange large datasets. By importing CSV files into numpy arrays, we can easily perform complex operations and analysis on the data, making numpy an essential tool for data scientists and researchers.

genfromtxt and loadtxt are two functions in the numpy library that can be used to read data from text files, including CSV files.

genfromtxt is a more advanced function that can be used to read text files that have more complex structures, including CSV files. genfromtxt can handle files that have missing or invalid data, or files that have columns of different data types. It can also be used to skip header lines or to read only specific columns from the file.

import numpy as np

padres = np.genfromtxt('files/padres.csv', delimiter=',', dtype=str, encoding='utf-8')
# delimiter indicates that the data is separated into columns which is distinguished by commas
# genfromtxt is used to read the csv file itself
# dtype is used to have numpy automatically detect the data type in the csv file

print(padres)
[['Name' ' Position' ' Average' ' HR' ' RBI' ' OPS' ' JerseyNumber']
 ['Manny Machado' ' 3B' ' .298' ' 32' ' 102' ' .897' ' 13']
 ['Fernando Tatis Jr' ' RF' ' .281' ' 42' ' 97' ' .975' ' 23']
 ['Juan Soto' ' LF' ' .242' ' 27' ' 62' ' .853' ' 22']
 ['Xander Bogaerts' ' SS' ' .307' ' 15' ' 73' ' .833' ' 2']
 ['Nelson Cruz' ' DH' ' .234' ' 10' ' 64' ' .651' ' 32']
 ['Matt Carpenter' ' DH' ' .305' ' 15' ' 37' ' 1.138' ' 14']
 ['Jake Cronenworth' ' 1B' ' .239' ' 17' ' 88' ' .722' ' 9']
 ['Ha-Seong Kim' ' 2B' ' .251' ' 11' ' 59' ' .708' ' 7']
 ['Trent Grisham' ' CF' ' .184' ' 17' ' 53' ' .626' ' 1']
 ['Luis Campusano' ' C' ' .250' ' 1' ' 5' ' .593' ' 12']
 ['Austin Nola' ' C' ' .251' ' 4' ' 40' ' .649' ' 26']
 ['Jose Azocar' ' OF' ' .257' ' 0' ' 10' ' .630' ' 28']]

loadtxt is a simpler function that can be used to read simple text files that have a regular structure, such as files that have only one type of data (such as all integers or all floats). loadtxt can be faster than genfromtxt because it assumes that the data in the file is well-structured and can be easily parsed.

import numpy as np

padres = np.loadtxt('files/padres.csv', delimiter=',', dtype=str, encoding='utf-8')
print(padres)
[['Name' ' Position' ' Average' ' HR' ' RBI' ' OPS' ' JerseyNumber']
 ['Manny Machado' ' 3B' ' .298' ' 32' ' 102' ' .897' ' 13']
 ['Fernando Tatis Jr' ' RF' ' .281' ' 42' ' 97' ' .975' ' 23']
 ['Juan Soto' ' LF' ' .242' ' 27' ' 62' ' .853' ' 22']
 ['Xander Bogaerts' ' SS' ' .307' ' 15' ' 73' ' .833' ' 2']
 ['Nelson Cruz' ' DH' ' .234' ' 10' ' 64' ' .651' ' 32']
 ['Matt Carpenter' ' DH' ' .305' ' 15' ' 37' ' 1.138' ' 14']
 ['Jake Cronenworth' ' 1B' ' .239' ' 17' ' 88' ' .722' ' 9']
 ['Ha-Seong Kim' ' 2B' ' .251' ' 11' ' 59' ' .708' ' 7']
 ['Trent Grisham' ' CF' ' .184' ' 17' ' 53' ' .626' ' 1']
 ['Luis Campusano' ' C' ' .250' ' 1' ' 5' ' .593' ' 12']
 ['Austin Nola' ' C' ' .251' ' 4' ' 40' ' .649' ' 26']
 ['Jose Azocar' ' OF' ' .257' ' 0' ' 10' ' .630' ' 28']]

Organize and get ride of brackets by iterating though the .csv

for i in padres:
    print(",".join(i))
Name, Position, Average, HR, RBI, OPS, JerseyNumber
Manny Machado, 3B, .298, 32, 102, .897, 13
Fernando Tatis Jr, RF, .281, 42, 97, .975, 23
Juan Soto, LF, .242, 27, 62, .853, 22
Xander Bogaerts, SS, .307, 15, 73, .833, 2
Nelson Cruz, DH, .234, 10, 64, .651, 32
Matt Carpenter, DH, .305, 15, 37, 1.138, 14
Jake Cronenworth, 1B, .239, 17, 88, .722, 9
Ha-Seong Kim, 2B, .251, 11, 59, .708, 7
Trent Grisham, CF, .184, 17, 53, .626, 1
Luis Campusano, C, .250, 1, 5, .593, 12
Austin Nola, C, .251, 4, 40, .649, 26
Jose Azocar, OF, .257, 0, 10, .630, 28

Pandas

What is Pandas

Pandas is a Python library used for working with data sets. A python library is something It has functions for analyzing, cleaning, exploring, and manipulating data.

Why Use Pandas?

Pandas allows us to analyze big data and make conclusions based on statistical theories. Pandas can clean messy data sets, and make them readable and relevant. Also it is a part of data analysis, and data manipulation.

What Can Pandas Do?

Pandas gives you answers about the data. Like:

  • Is there a correlation between two or more columns?
  • What is average value?
  • Max value
  • Min value
  • How to load data
  • Delete data
  • Sort Data.

Pandas are also able to delete rows that are not relevant, or contains wrong values, like empty or NULL values. This is called cleaning the data.

Basics of Pandas.

import pandas as pd
# What this does is it calls the python pandas library and this code segment is needed whenever incorporating pandas.

DICTIONARIES AND DATASETS

  • One way you are able to manipulate a pandas data set is by creating a dictionary and calling it as seen with the dict data 1 and pd.dataframe which is a way to print the set.
import pandas as pd

data1 = {
  'teams': ["BARCA", "REAL", "ATLETICO"],
  'standings': [1, 2, 3]
}

myvar = pd.DataFrame(data1)
print(data1)
print("vs.")
print(myvar)
{'teams': ['BARCA', 'REAL', 'ATLETICO'], 'standings': [1, 2, 3]}
vs.
      teams  standings
0     BARCA          1
1      REAL          2
2  ATLETICO          3

Indexing and manipulaton of data through lists.

  • With pandas you can also organize the data which is one of its biggest perks, we call this indexing, this is when we define the first column in a data frame.
import pandas as pd 

score = [5/5, 5/5, 1/5]

myvar = pd.Series(score, index = ["math", "science", "pe"])

print(myvar)
math       1.0
science    1.0
pe         0.2
dtype: float64

Pandas Classes

Within pandas the library consists of a lot of functions which allow you to manipulate datasets in lists dictionaries and csv files here are some of the ones we are going to cover (hint: take notes on these)

  • Series: a one-dimensional array which holds any data type supported in Python and uses labels to locate each data value for retrieval
  • Index: used to get the index of a given Series and DataFrames
  • PeriodIndex: Immutable ndarray holding ordinal values indicating regular periods in time. ex. years, months...
  • DataframeGroupedBy: used to organize data and calculate the different mathematical functions
  • Categorical: a pandas data type corresponding to categorical variables in statistics, sets up a category for something and puts it within the categories and allows for better organization
  • Time Stamp: Pandas equivalent to python datetime.datetime object, sets dates

PeriodIndex

  • This allows for a way to repeat data over time that it occurs as seen from january 2022 to december 2023. You can use Y for years, M for months, and D for days.
import pandas as pd


time = pd.period_range('2022-01', '2022-12', freq='M') # you can change freq to Y for years, D for days


print(time)
PeriodIndex(['2022-01', '2022-02', '2022-03', '2022-04', '2022-05', '2022-06',
             '2022-07', '2022-08', '2022-09', '2022-10', '2022-11', '2022-12'],
            dtype='period[M]')

Now implement a way to show a period index from June 2022 to July 2023 in days.

time = pd.period_range('2022-06', '2023-06', freq='D') 


print(time)
PeriodIndex(['2022-06-01', '2022-06-02', '2022-06-03', '2022-06-04',
             '2022-06-05', '2022-06-06', '2022-06-07', '2022-06-08',
             '2022-06-09', '2022-06-10',
             ...
             '2023-05-23', '2023-05-24', '2023-05-25', '2023-05-26',
             '2023-05-27', '2023-05-28', '2023-05-29', '2023-05-30',
             '2023-05-31', '2023-06-01'],
            dtype='period[D]', length=366)

Dataframe Grouped By

  • This allows for you to organize your data and calculate the different functions such as
  • count(): returns the number of non-null values in each group.
  • sum(): returns the sum of values in each group.
  • mean(): returns the mean of values in each group.
  • min(): returns the minimum value in each group.
  • max(): returns the maximum value in each group.
  • median(): returns the median of values in each group.
  • var(): returns the variance of values in each group.
  • agg(): applies one or more functions to each group and returns a new DataFrame with the results.
import pandas as pd

data = {
    'Category': ['E', 'F', 'E', 'F', 'E', 'F', 'E', 'F'],
    'Value': [100, 250, 156, 255, 240, 303, 253, 3014]
}
df = pd.DataFrame(data)


grouped = df.groupby('Category') #GUESS WHAT THIS WOULD BE IF WE WERE LOOKING FOR COMBINED TOTALS!()
# print sum or variables

print(grouped)
<pandas.core.groupby.generic.DataFrameGroupBy object at 0x7fef31197ac0>

Categorical

  • This sets up a category for something and puts it within the categories and allows for better organization
import pandas as pd

colors = pd.Categorical(['yellow', 'orange', 'blue', 'yellow', 'orange'], categories=['yellow', 'orange', 'blue'])
# categories for repeated values
print(colors)
['yellow', 'orange', 'blue', 'yellow', 'orange']
Categories (3, object): ['yellow', 'orange', 'blue']

Timestamp Class

  • This allows to display a single time which can be useful when working with datasets that deal with time allowing you to manipulate the time you do something and how you do it.
import pandas as pd


timing = pd.Timestamp('2023-02-05 02:00:00')

print(timing) #WHAT WOULD THIS BE
2023-02-05 02:00:00

CSV FILES!

  • A csv file contains data and within pandas you are able to call the function and you are able to manipulate the data with the certain data classes talked about above.
  • Name, Position, Average, HR, RBI, OPS, JerseyNumber (headers of columns)
  • Manny Machado, 3B, .298, 32, 102, .897, 13
  • Tatis Jr, RF, .281, 42, 97, .975, 23
  • Juan Soto, LF, .242, 27, 62, .853, 22
  • Xanger Bogaerts, SS, .307, 15, 73, .833, 2
  • Nelson Cruz, DH, .234, 10, 64, .651, 32
  • Matt Carpenter, DH, .305, 15, 37, 1.138, 14
  • Cronezone, 1B, .239, 17, 88, .722, 9
  • Ha-Seong Kim, 2B, .251, 11, 59, .708, 7
  • Trent Grisham, CF, .184, 17, 53, .626, 1
  • Luis Campusano, C, .250, 1, 5, .593, 12
  • Austin Nola, C, .251, 4, 40, .649, 26
  • Jose Azocar, OF, .257, 0, 10, .630, 28

QUESTION: WHAT DO YOU GUYS THINK THE INDEX FOR THIS WOULD BE?

Can you explain what is going on in this code segment below. (hint: define what ascending= false means, and df. head means)

  • ascending sorts the data values low to high but since it is false it will load high to low
  • df.head means that it will print the first/top 10 values
  • df.tail means that it will print the last/bottom 10 values
import pandas as pd

#read csv and sort 'Duration' largest to smallest
df = pd.read_csv('files/padres.csv').sort_values(by=['Name'], ascending=False)

print("--Duration Top 10---------")
print(df.head(10))

print("--Duration Bottom 10------")
print(df.tail(10))
print(', '.join(df.tail(10)))
--Duration Top 10---------
                Name  Position   Average   HR   RBI    OPS   JerseyNumber
3    Xander Bogaerts        SS     0.307   15    73  0.833              2
8      Trent Grisham        CF     0.184   17    53  0.626              1
4        Nelson Cruz        DH     0.234   10    64  0.651             32
5     Matt Carpenter        DH     0.305   15    37  1.138             14
0      Manny Machado        3B     0.298   32   102  0.897             13
9     Luis Campusano         C     0.250    1     5  0.593             12
2          Juan Soto        LF     0.242   27    62  0.853             22
11       Jose Azocar        OF     0.257    0    10  0.630             28
6   Jake Cronenworth        1B     0.239   17    88  0.722              9
7       Ha-Seong Kim        2B     0.251   11    59  0.708              7
--Duration Bottom 10------
                 Name  Position   Average   HR   RBI    OPS   JerseyNumber
4         Nelson Cruz        DH     0.234   10    64  0.651             32
5      Matt Carpenter        DH     0.305   15    37  1.138             14
0       Manny Machado        3B     0.298   32   102  0.897             13
9      Luis Campusano         C     0.250    1     5  0.593             12
2           Juan Soto        LF     0.242   27    62  0.853             22
11        Jose Azocar        OF     0.257    0    10  0.630             28
6    Jake Cronenworth        1B     0.239   17    88  0.722              9
7        Ha-Seong Kim        2B     0.251   11    59  0.708              7
1   Fernando Tatis Jr        RF     0.281   42    97  0.975             23
10        Austin Nola         C     0.251    4    40  0.649             26
Name,  Position,  Average,  HR,  RBI,  OPS,  JerseyNumber
import pandas as pd


df = pd.read_csv("./files/housing.csv")


mode_total_rooms = df['total_rooms'].mode()


print(f"The mode of the 'total_rooms' column is: {mode_total_rooms}")
The mode of the 'total_rooms' column is: 0    1527.0
Name: total_rooms, dtype: float64
import pandas as pd

df = pd.read_csv("./files/housing.csv")


grouped_df = df.groupby('total_rooms')


agg_df = grouped_df.agg({'total_rooms': 'sum', 'population': 'mean', 'longitude': 'count'})

# WHAT DO YOU GUYS THINK df.agg means in context of pandas and what does it stand for. 
# df.agg means the aggregation of the data set, printing the total sum of the group


print(agg_df)
             total_rooms  population  longitude
total_rooms                                    
2.0                  2.0         6.0          1
6.0                  6.0         8.0          1
8.0                  8.0        13.0          1
11.0                11.0        24.0          1
12.0                12.0        18.0          1
...                  ...         ...        ...
30450.0          30450.0      9419.0          1
32054.0          32054.0     15507.0          1
32627.0          32627.0     28566.0          1
37937.0          37937.0     16122.0          1
39320.0          39320.0     16305.0          1

[5926 rows x 3 columns]

Our Frontend Data Analysis Project

Link

Popcorn Hacks

  • Complete fill in the blanks for Predictive Analysis Numpy
  • Takes notes on Panda where it asks you to
  • Complete code segment tasks in Panda and Numpy

Main Hack

  • Make a data file - content is up to you, just make sure there are integer values - and print
  • Run Panda and Numpy commands
    • Panda:
      • Find Min and Max values
      • Sort in order - can be order of least to greatest or vice versa
      • Create a smaller dataframe and merge it with your data file
    • Numpy:
      • Random number generation
      • create a multi-dimensional array (multiple elements)
      • create an array with linearly spaced intervals between values
import numpy as np

SOURalbum = np.loadtxt('files/SOURalbum.csv', delimiter=',', dtype=str, encoding='utf-8')

print(SOURalbum)
# printing csv file
[['Song Number in Album' ' Title' ' Duration']
 ['1' ' brutal' ' 2.24']
 ['2' ' traitor' ' 3.50']
 ['3' ' drivers license' ' 4.03']
 ['4' ' 1 step forward 3 steps back' ' 2.44']
 ['5' ' deja vu' ' 3.36']
 ['6' ' good 4 u' ' 2.59']
 ['7' ' enough for you' ' 3.23 ']
 ['8' ' happier' ' 2.56']
 ['9' ' jealousy jealousy' ' 2.54']
 ['10' ' favorite crime' ' 2.33']
 ['11' ' hope ur ok' ' 3.30']]
import pandas as pd
df = pd.DataFrame(SOURalbum)
print(df)
# putting in a dataframe
                       0                             1          2
0   Song Number in Album                         Title   Duration
1                      1                        brutal       2.24
2                      2                       traitor       3.50
3                      3               drivers license       4.03
4                      4   1 step forward 3 steps back       2.44
5                      5                       deja vu       3.36
6                      6                      good 4 u       2.59
7                      7                enough for you      3.23 
8                      8                       happier       2.56
9                      9             jealousy jealousy       2.54
10                    10                favorite crime       2.33
11                    11                    hope ur ok       3.30
SOURalbum = pd.read_csv("files/SOURalbum.csv")
durations = SOURalbum['Duration'].tolist()

print(durations)
[2.24, 3.5, 4.03, 2.44, 3.36, 2.59, 3.23, 2.56, 2.54, 2.33, 3.3]
print("Maximum duration is: ")
print(np.max(durations))
Maximum duration is: 
4.03
print("Minimum duration is: ")
print(np.min(durations))
Minimum duration is: 
2.24
durations_sorted = pd.read_csv('files/SOURalbum.csv').sort_values(by=['Duration'], ascending=True)
print(durations_sorted)
    Song Number in Album                         Title  Duration
0                      1                        brutal      2.24
9                     10                favorite crime      2.33
3                      4   1 step forward 3 steps back      2.44
8                      9             jealousy jealousy      2.54
7                      8                       happier      2.56
5                      6                      good 4 u      2.59
6                      7                enough for you      3.23
10                    11                    hope ur ok      3.30
4                      5                       deja vu      3.36
1                      2                       traitor      3.50
2                      3               drivers license      4.03
df2 = pd.DataFrame({
    'Song Number in Album': [11, 12],
    'Title': ['Wonderin', 'Just For A Moment'],
    'Duration': [3.53, 3.27] 
})
df = pd.read_csv('files/SOURalbum.csv').sort_values(by=['Song Number in Album'], ascending=True)
print('Before merging:')
print(df)

#merged_df = pd.merge(df, df2, on='Song Number in Album')
#print(merged_df)

print('After merging:')
pd.concat([df, df2], axis=0)
Before merging:
    Song Number in Album                         Title  Duration
0                      1                        brutal      2.24
1                      2                       traitor      3.50
2                      3               drivers license      4.03
3                      4   1 step forward 3 steps back      2.44
4                      5                       deja vu      3.36
5                      6                      good 4 u      2.59
6                      7                enough for you      3.23
7                      8                       happier      2.56
8                      9             jealousy jealousy      2.54
9                     10                favorite crime      2.33
10                    11                    hope ur ok      3.30
After merging:
Song Number in Album Title Duration
0 1 brutal 2.24
1 2 traitor 3.50
2 3 drivers license 4.03
3 4 1 step forward 3 steps back 2.44
4 5 deja vu 3.36
5 6 good 4 u 2.59
6 7 enough for you 3.23
7 8 happier 2.56
8 9 jealousy jealousy 2.54
9 10 favorite crime 2.33
10 11 hope ur ok 3.30
0 11 Wonderin 3.53
1 12 Just For A Moment 3.27
import numpy as np
# for infinite range:

# Set the maximum value of the range
max_int = np.iinfo(np.int32).max

# Generate a random integer between 1 and max_int (inclusive)
rand_int = np.random.randint(1, max_int + 1)

print(rand_int)
235637119
import numpy as np

# Create a 2-dimensional array about dogs (True/False for if has all shots/vaccines) 
dog_array = np.array([
    ["Elly", "Rottweiler ", 10, True],
    ["Athyna", "Pitbull", 9, True],
    ["Oakley", "Bulldog/Terrier/Husky... Mutt", 1, False]
])

print(dog_array)

dog_df = pd.DataFrame(dog_array, columns=["Name", "Breed", "Age", "All Shots/Vaccines"])
print()

print (dog_df)
[['Elly' 'Rottweiler ' '10' 'True']
 ['Athyna' 'Pitbull' '9' 'True']
 ['Oakley' 'Bulldog/Terrier/Husky... Mutt' '1' 'False']]

     Name                          Breed Age All Shots/Vaccines
0    Elly                    Rottweiler   10               True
1  Athyna                        Pitbull   9               True
2  Oakley  Bulldog/Terrier/Husky... Mutt   1              False
import numpy as np

# Create a 2-dimensional array with 3 rows and 4 columns, with linearly spaced ages
dog_array = np.array([
    ["Elly", "Rottweiler ", *np.linspace(0, 10, num=3), True],
    ["Athyna", "Pibull", *np.linspace(0, 10, num=3), True],
    ["Oakley", "Bulldog/Terrier/Husky...Mutt", *np.linspace(0, 10, num=3), False]
])

print(dog_array)
[['Elly' 'Rottweiler ' '0.0' '5.0' '10.0' 'True']
 ['Athyna' 'Pibull' '0.0' '5.0' '10.0' 'True']
 ['Oakley' 'Bulldog/Terrier/Husky...Mutt' '0.0' '5.0' '10.0' 'False']]

Grading

The grading will be binary - all or nothing; no partial credit

  • 0.3 for all the popcorn hacks
  • 0.6 for the main hack - CSV file
  • 0.1 for going above and beyond in the main hack