Python is a simple tutorial for data analysis, and python uses data analysis

Python is a simple tutorial for data analysis, and python uses data analysis

Recently, Analysis with Programming has joined Planet Python. As the first special blog of this website, I will share with you how to start data analysis using Python. The details are as follows:

Data Import
Import local or web-side CSV files;
Data transformation;
Data Statistics description;
Hypothesis Test
One sample T-test;
Visualization;
Create a UDF.

Data Import

This is a key step. We need to import data for subsequent analysis. Generally, the data is in CSV format, and can be converted to at least CSV format, even if not. In Python, the operations are as follows:

import pandas as pd # Reading data locallydf = pd.read_csv('/Users/al-ahmadgaidasaad/Documents/d.csv') # Reading data from webdata_url = "https://raw.githubusercontent.com/alstat/Analysis-with-Programming/master/2014/Python/Numerical-Descriptions-of-the-Data/data.csv"df = pd.read_csv(data_url)

To read the local CSV file, we need the relevant modules in the pandas data analysis database. The read_csv function can read local and web data.

Data Transformation

Since there is data in the workspace, the next step is data transformation. Statisticians and scientists usually remove unnecessary data from the analysis at this step. Let's first look at the data:

# Head of the dataprint df.head() # OUTPUT Abra Apayao Benguet Ifugao Kalinga0 1243 2934  148 3300 105531 4158 9235  4287 8063 352572 1787 1922  1955 1074  45443 17152 14501  3536 19607 316874 1266 2385  2530 3315  8520 # Tail of the dataprint df.tail() # OUTPUT  Abra Apayao Benguet Ifugao Kalinga74 2505 20878  3519 19737 1651375 60303 40065  7062 19422 6180876 6311 6756  3561 15910 2334977 13345 38902  2583 11096 6866378 2623 18264  3745 16787 16900

For R programmers, the above operations are equivalent to print (head (df) to print the first six rows of data, and print (tail (df )) to print the last six rows of data. Of course, in Python, 5 rows are printed by default, while R is 6 rows. Therefore, the R code head (df, n = 10) is df. head (n = 10) in Python, and the print data tail is the same.

In the R language, the names of Data columns and rows are extracted by colnames and rownames respectively. In Python, columns and index attributes are used for extraction, as shown below:

# Extracting column namesprint df.columns # OUTPUTIndex([u'Abra', u'Apayao', u'Benguet', u'Ifugao', u'Kalinga'], dtype='object') # Extracting row names or the indexprint df.index # OUTPUTInt64Index([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78], dtype='int64')

The T method is used for data forwarding,

# Transpose dataprint df.T # OUTPUT   0  1  2  3  4  5  6  7  8  9 Abra  1243 4158 1787 17152 1266 5576 927 21540 1039 5424 Apayao 2934 9235 1922 14501 2385 7452 1099 17038 1382 10588 Benguet 148 4287 1955 3536 2530 771 2796 2463 2592 1064 Ifugao 3300 8063 1074 19607 3315 13134 5134 14226 6842 13828 Kalinga 10553 35257 4544 31687 8520 28252 3106 36238 4973 40140     ...  69  70  71  72  73  74  75  76  77 Abra  ... 12763 2470 59094 6209 13316 2505 60303 6311 13345 Apayao ... 37625 19532 35126 6335 38613 20878 40065 6756 38902 Benguet ...  2354 4045 5987 3530 2585 3519 7062 3561 2583 Ifugao ...  9838 17125 18940 15560 7746 19737 19422 15910 11096 Kalinga ... 65782 15279 52437 24385 66148 16513 61808 23349 68663     78 Abra  2623 Apayao 18264 Benguet 3745 Ifugao 16787 Kalinga 16900 

Other transformations, such as sorting, use the sort attribute. Now we extract data from a specific column. In Python, iloc or ix attributes can be used. But I prefer ix because it is more stable. Suppose we need the first five rows in the first column of the data, we have:

print df.ix[:, 0].head() # OUTPUT0  12431  41582  17873 171524  1266Name: Abra, dtype: int64

By the way, Python indexes start from 0 rather than 1. To retrieve the first three columns of data from 11 to 20 rows, we have:

print df.ix[10:20, 0:3] # OUTPUT Abra Apayao Benguet10 981 1311  256011 27366 15093  303912 1100 1701  238213 7212 11001  108814 1048 1427  284715 25679 15661  294216 1055 2191  211917 5437 6461  73418 1029 1183  230219 23710 12222  259820 1091 2343  2654

The preceding command is equivalent to df. ix [, ['aba', 'ayao', 'benguet '].

To discard columns in data, column 1 (Apayao) and column 2 (Benguet) are used. The drop attribute is used as follows:

print df.drop(df.columns[[1, 2]], axis = 1).head() # OUTPUT Abra Ifugao Kalinga0 1243 3300 105531 4158 8063 352572 1787 1074  45443 17152 19607 316874 1266 3315  8520

The axis parameter tells the function whether to discard columns or rows. If axis is equal to 0, the row is discarded.

Statistical description

The next step is to describe the statistical characteristics of data through the describe attribute:

print df.describe() # OUTPUT    Abra  Apayao  Benguet  Ifugao  Kalingacount  79.000000  79.000000 79.000000  79.000000  79.000000mean 12874.379747 16860.645570 3237.392405 12414.620253 30446.417722std 16746.466945 15448.153794 1588.536429 5034.282019 22245.707692min  927.000000 401.000000 148.000000 1074.000000 2346.00000025%  1524.000000 3435.500000 2328.000000 8205.000000 8601.50000050%  5790.000000 10588.000000 3202.000000 13044.000000 24494.00000075% 13330.500000 33289.000000 3918.500000 16099.500000 52510.500000max 60303.000000 54625.000000 8813.000000 21031.000000 68663.000000

Hypothesis Test

Python has a good statistical inference package. That is the stats in scipy. Ttest_1samp enables a single sample t-test. Therefore, if we want to test the average rice yield in the Abra column through the zero hypothesis, we assume that the average rice yield is 15000, And we have:

from scipy import stats as ss # Perform one sample t-test using 1500 as the true meanprint ss.ttest_1samp(a = df.ix[:, 'Abra'], popmean = 15000) # OUTPUT(-1.1281738488299586, 0.26270472069109496)

Returns the ancestor composed of the following values:

T: floating point or array type
T statistic
Prob: floating point or array type
Two-tailed p-value bilateral probability value

Through the above output, we can see that the P value is 0.267 much greater than α = 0.05, so there is no sufficient evidence that the average rice yield is not 150000. Apply this test to all variables, and assume that the mean value is 15000. We have:

print ss.ttest_1samp(a = df, popmean = 15000) # OUTPUT(array([ -1.12817385, 1.07053437, -65.81425599, -4.564575 , 6.17156198]), array([ 2.62704721e-01, 2.87680340e-01, 4.15643528e-70,   1.83764399e-05, 2.82461897e-08]))

The first array is the t statistic, and the second array is the corresponding P value.

Visualization

Python has many visualization modules, and the most popular one is the matpalotlib library. We can also select the bokeh and seaborn modules. In my previous blog post, I have explained the function of the box map module in the matplotlib library.

# Import the module for plottingimport matplotlib.pyplot as plt plt.show(df.plot(kind = 'box'))

Now, we can use the ggplot topic Integrated with R in the pandas module to beautify the chart. To use ggplot, we only need to add a line in the above Code,

import matplotlib.pyplot as pltpd.options.display.mpl_style = 'default' # Sets the plotting display theme to ggplot2df.plot(kind = 'box')

In this way, we can get the table as follows:

It is much simpler than the matplotlib. pyplot topic. However, in this blog, I prefer to introduce the seaborn module, which is a data visualization library. Therefore, we have:

# Import the seaborn libraryimport seaborn as sns # Do the boxplotplt.show(sns.boxplot(df, widths = 0.5, color = "pastel"))

More sexy box chart, continue to look down.

plt.show(sns.violinplot(df, widths = 0.5, color = "pastel"))

plt.show(sns.distplot(df.ix[:,2], rug = True, bins = 15))

with sns.axes_style("white"): plt.show(sns.jointplot(df.ix[:,1], df.ix[:,2], kind = "kde"))

plt.show(sns.lmplot("Benguet", "Ifugao", df))

Create a UDF

In Python, we use the def function to implement a custom function. For example, if we want to define a function that adds two numbers, we can:

def add_2int(x, y): return x + y print add_2int(2, 2) # OUTPUT4

By the way, indentation in Python is very important. Define the function scope through indentation, just like using braces {…} in the R Language {...} Same. Here is an example of our previous blog:

Generates 10 normal distribution samples, u = 3 and o.
Calculate x_bar and x_bar2 Based on the confidence level of 95%;
Repeat 100 times; then
Calculate the percentage of the confidence interval containing the real mean.

In Python, the program is as follows:

import numpy as npimport scipy.stats as ss def case(n = 10, mu = 3, sigma = np.sqrt(5), p = 0.025, rep = 100): m = np.zeros((rep, 4))  for i in range(rep):  norm = np.random.normal(loc = mu, scale = sigma, size = n)  xbar = np.mean(norm)  low = xbar - ss.norm.ppf(q = 1 - p) * (sigma / np.sqrt(n))  up = xbar + ss.norm.ppf(q = 1 - p) * (sigma / np.sqrt(n))   if (mu > low) & (mu < up):   rem = 1  else:   rem = 0   m[i, :] = [xbar, low, up, rem]  inside = np.sum(m[:, 3]) per = inside / rep desc = "There are " + str(inside) + " confidence intervals that contain "   "the true mean (" + str(mu) + "), that is " + str(per) + " percent of the total CIs"  return {"Matrix": m, "Decision": desc}

The above code is easy to read, but the cycle is slow. The above code is improved below, thanks to Python experts.

import numpy as npimport scipy.stats as ss def case2(n = 10, mu = 3, sigma = np.sqrt(5), p = 0.025, rep = 100): scaled_crit = ss.norm.ppf(q = 1 - p) * (sigma / np.sqrt(n)) norm = np.random.normal(loc = mu, scale = sigma, size = (rep, n))  xbar = norm.mean(1) low = xbar - scaled_crit up = xbar + scaled_crit  rem = (mu > low) & (mu < up) m = np.c_[xbar, low, up, rem]  inside = np.sum(m[:, 3]) per = inside / rep desc = "There are " + str(inside) + " confidence intervals that contain "   "the true mean (" + str(mu) + "), that is " + str(per) + " percent of the total CIs" return {"Matrix": m, "Decision": desc}