机器学习怎么学？
- 机器学习包含数学原理推导和实际应用技巧，所以需要清楚算法的推导过程和如何应用。
- 深度学习是机器学习中神经网络算法的延伸，在计算机视觉和自然语言处理中应用更厉害一些。
- 自己从头开始做笔记。
机器学习怎么动手，哪里去找案例？
- 最好的资源：github ，kaggle
- 案例积累的作用很大，很少从头去写一个项目。先学会模仿，再去创作。
科学计算库Numpy
numpy(Numerical Python extensions)是一个第三方的Python包，用于科学计算。这个库的前身是1995年就开始开发的一个用于数组运算的库。经过了长时间的发展，基本上成了绝大部分Python科学计算的基础包，当然也包括所有提供Python接口的深度学习框架。
numpy.genfromtxt方法
从文本文件加载数据，并按指定的方式处理缺少的值
delimiter : 分隔符：用于分隔值的字符串。可以是str, int, or sequence。默认情况下，任何连续的空格作为分隔符。
dtype：结果数组的数据类型。 如果没有，则dtypes将由每列的内容单独确定。
import numpy
world_alcohol = numpy.genfromtxt("world_alcohol.txt",delimiter=",",dtype=str)
print(type(world_alcohol))
print(world_alcohol)
print(help(numpy.genfromtxt)) #当想知道numpy.genfromtxt用法时，使用help查询帮助文档
输出结果：
<class 'numpy.ndarray'> #所有的numpy都是ndarray结构
[['Year' 'WHO region' 'Country' 'Beverage Types' 'Display Value']
['1986' 'Western Pacific' 'Viet Nam' 'Wine' '0']
['1986' 'Americas' 'Uruguay' 'Other' '0.5']
...,
['1987' 'Africa' 'Malawi' 'Other' '0.75']
['1989' 'Americas' 'Bahamas' 'Wine' '1.5']
['1985' 'Africa' 'Malawi' 'Spirits' '0.31']]
numpy.array
创建一个向量或矩阵（多维数组）
import numpy as np
a = [1, 2, 4, 3] #vector
b = np.array(a) # array([1, 2, 4, 3])
type(b) # <type 'numpy.ndarray'>
对数组元素的操作1
b.shape # (4,) 返回矩阵的（行数，列数）或向量中的元素个数
b.argmax() # 2 返回最大值所在的索引
b.max() # 4最大值
b.min() # 1最小值
b.mean() # 2.5平均值
numpy限制了nump.array中的元素必须是相同数据结构。使用dtype属性返回数组中的数据类型
>>> a = [1,2,3,5]
>>> b = np.array(a)
>>> b.dtype
dtype('int64')
对数组元素的操作2
c = [[1, 2], [3, 4]] # 二维列表
d = np.array(c) # 二维numpy数组
d.shape # (2, 2)
d[1,1] #4,矩阵方式按照行、列获取元素
d.size # 4 数组中的元素个数
d.max(axis=0) # 找维度0，也就是最后一个维度上的最大值，array([3, 4])
d.max(axis=1) # 找维度1，也就是倒数第二个维度上的最大值，array([2, 4])
d.mean(axis=0) # 找维度0，也就是第一个维度上的均值，array([ 2., 3.])
d.flatten() # 展开一个numpy数组为1维数组，array([1, 2, 3, 4])
np.ravel(c) # 展开一个可以解析的结构为1维数组，array([1, 2, 3, 4])
对数组元素的操作3
import numpy as np
matrix = np.array([
[5,10,15],
[20,25,30],
[35,40,45]
])
print(matrix.sum(axis=1)) #指定维度axis=1，即按行计算
输出结果：
[ 30 75 120]
import numpy as np
matrix = np.array([
[5,10,15],
[20,25,30],
[35,40,45]
])
print(matrix.sum(axis=0)) #指定维度axis=0，即按列计算
输出结果：
[60 75 90]
矩阵中也可以使用切片
import numpy as np
vector = [1, 2, 4, 3]
print(vector[0:3]) #[1, 2, 4] 对于索引大于等于0，小于3的所有元素
matrix = np.array([[5,10,15],[20,25,30],[35,40,45]])
print(matrix[:,1]) #[10 25 40]取出所有行的第一列
print(matrix[:,0:2]) #取出所有行的第一、第二列
#[[ 5 10]
[20 25]
[35 40]]
对数组的判断操作，等价于对数组中所有元素的操作
import numpy as np
matrix = np.array([[5,10,15],[20,25,30],[35,40,45]])
print(matrix == 25)
输出结果：
[[False False False]
[False True False]
[False False False]]
second_colum_25 = matrix[:,1]== 25
print(second_colum_25)
print(matrix[second_colum_25,:]) #bool类型的值也可以拿出来当成索引
输出结果：
[False True False]
[[20 25 30]]
对数组元素的与操作,或操作
import numpy as np
vector = np.array([5,10,15,20])
equal_to_ten_and_five = (vector == 10) & (vector == 5)
print (equal_to_ten_and_five)
输出结果：
[False False False False]
import numpy as np
vector = np.array([5,10,15,20])
equal_to_ten_and_five = (vector == 10) | (vector == 5)
print (equal_to_ten_and_five)
vector[equal_to_ten_and_five] = 50 #bool类型值作为索引时，True有效
print(vector)
输出结果：
[ True True False False]
[50 50 15 20]
对数组元素类型的转换
import numpy as np
vector = np.array(['lucy','ch','dd'])
vector = vector.astype(float) #astype对整个vector进行值类型的转换
print(vector.dtype)
print(vector)
输出结果：
float64
[ 5. 10. 15. 20.]
Numpy常用函数
reshape方法，变换矩阵维度
import numpy as np
print(np.arange(15))
a = np.arange(15).reshape(3,5) #将向量变为3行5列矩阵
print(a)
print(a.shape) #shape方法获得（行数，烈数）
输出结果：
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
(3, 5)
初始化矩阵为0或1
>>> import numpy as np
>>> np.zeros((3,4)) #将一个三行四列矩阵初始化为0
输出结果：
array([[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.]])
>>> import numpy as np
>>> np.ones((3,4),dtype=np.int32) #指定类型为int型
输出结果：
array([[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]], dtype=int32)
构造序列
np.arange( 10, 30, 5 ) #起始值10，终止值小于30，间隔为5
输出结果：
array([10, 15, 20, 25])
np.arange( 0, 2, 0.3 )
输出结果：
array([ 0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])
random模块
np.random.random((2,3)) #random模块中的random函数，产生一个两行三列的随机矩阵。（-1，+1）之间的值
输出结果：
array([[ 0.40130659, 0.45452825, 0.79776512],
[ 0.63220592, 0.74591134, 0.64130737]])
linspace模块，将起始值与终止值之间等分成x份
from numpy import pi
np.linspace( 0, 2*pi, 100 )
输出结果：
array([ 0. , 0.06346652, 0.12693304, 0.19039955, 0.25386607,
0.31733259, 0.38079911, 0.44426563, 0.50773215, 0.57119866,
0.63466518, 0.6981317 , 0.76159822, 0.82506474, 0.88853126,
0.95199777, 1.01546429, 1.07893081, 1.14239733, 1.20586385,
1.26933037, 1.33279688, 1.3962634 , 1.45972992, 1.52319644,
1.58666296, 1.65012947, 1.71359599, 1.77706251, 1.84052903,
1.90399555, 1.96746207, 2.03092858, 2.0943951 , 2.15786162,
2.22132814, 2.28479466, 2.34826118, 2.41172769, 2.47519421,
2.53866073, 2.60212725, 2.66559377, 2.72906028, 2.7925268 ,
2.85599332, 2.91945984, 2.98292636, 3.04639288, 3.10985939,
3.17332591, 3.23679243, 3.30025895, 3.36372547, 3.42719199,
3.4906585 , 3.55412502, 3.61759154, 3.68105806, 3.74452458,
3.8079911 , 3.87145761, 3.93492413, 3.99839065, 4.06185717,
4.12532369, 4.1887902 , 4.25225672, 4.31572324, 4.37918976,
4.44265628, 4.5061228 , 4.56958931, 4.63305583, 4.69652235,
4.75998887, 4.82345539, 4.88692191, 4.95038842, 5.01385494,
5.07732146, 5.14078798, 5.2042545 , 5.26772102, 5.33118753,
5.39465405, 5.45812057, 5.52158709, 5.58505361, 5.64852012,
5.71198664, 5.77545316, 5.83891968, 5.9023862 , 5.96585272,
6.02931923, 6.09278575, 6.15625227, 6.21971879, 6.28318531])
对矩阵的运算以矩阵为单位进行操作
import numpy as np
a = np.array( [20,30,40,50] )
b = np.arange( 4 ) #[0 1 2 3]
c = a-b
print(c) #[20 29 38 47]
print(b**2) #[0 1 4 9]
print(a<35) #[ True True False False]
矩阵乘法
A = np.array( [[1,1],
[0,1]] )
B = np.array( [[2,0],
[3,4]] )
print A.dot(B) #求矩阵乘法的方法一
print np.dot(A, B) ##求矩阵乘法的方法二
输出结果：
[[5 4]
[3 4]]
[[5 4]
[3 4]]
e为底数的运算&开根运算
import numpy as np
B = np.arange(3)
print (np.exp(B)) #[ 1. 2.71828183 7.3890561 ] e的B次方
print (np.sqrt(B)) #[ 0. 1. 1.41421356]
floor向下取整
import numpy as np
a = np.floor(10*np.random.random((3,4))) #floor向下取整
print(a)
print (a.ravel()) #将矩阵中元素展开成一行
a.shape = (6, 2) #当采用a.reshape(6,-1) 第二个参数-1表示默认根据行数确定列数
print (a)
print (a.T) #a的转置（矩阵行列互换）
[[ 8. 7. 2. 1.]
[ 5. 2. 5. 1.]
[ 8. 7. 7. 2.]]
[ 8. 7. 2. 1. 5. 2. 5. 1. 8. 7. 7. 2.]
[[ 8. 7.]
[ 2. 1.]
[ 5. 2.]
[ 5. 1.]
[ 8. 7.]
[ 7. 2.]]
[[ 8. 2. 5. 5. 8. 7.]
[ 7. 1. 2. 1. 7. 2.]]
hstack与vstack实现矩阵的拼接（拼接数据常用）
a = np.floor(10*np.random.random((2,2)))
b = np.floor(10*np.random.random((2,2)))
print(a)
print(b)
print(np.hstack((a,b))) #横着拼接
print(np.vstack((a,b))) #竖着拼接
输出结果：
[[ 8. 6.]
[ 7. 6.]]
[[ 3. 4.]
[ 8. 1.]]
[[ 8. 6. 3. 4.]
[ 7. 6. 8. 1.]]
[[ 8. 6.]
[ 7. 6.]
[ 3. 4.]
[ 8. 1.]]
hsplit与vsplit实现矩阵的切分
a = np.floor(10*np.random.random((2,12)))
print(a)
print(np.hsplit(a,3)) #横着将矩阵切分为3份
print(np.hsplit(a,(3,4))) # 指定横着切分的位置，第三列和第四列
输出结果：
[[ 7. 1. 4. 9. 8. 8. 5. 9. 6. 6. 9. 4.]
[ 1. 9. 1. 2. 9. 9. 5. 0. 5. 4. 9. 6.]]
[array([[ 7., 1., 4., 9.],
[ 1., 9., 1., 2.]]), array([[ 8., 8., 5., 9.],
[ 9., 9., 5., 0.]]), array([[ 6., 6., 9., 4.],
[ 5., 4., 9., 6.]])]
[array([[ 7., 1., 4.],
[ 1., 9., 1.]]), array([[ 9.],
[ 2.]]), array([[ 8., 8., 5., 9., 6., 6., 9., 4.],
[ 9., 9., 5., 0., 5., 4., 9., 6.]])]
a = np.floor(10*np.random.random((12,2)))
print(a)
np.vsplit(a,3) #竖着将矩阵切分为3份
输出结果：
[[ 6. 4.]
[ 0. 1.]
[ 9. 0.]
[ 0. 0.]
[ 0. 4.]
[ 1. 1.]
[ 0. 4.]
[ 1. 6.]
[ 9. 7.]
[ 0. 9.]
[ 6. 1.]
[ 3. 0.]]
[array([[ 6., 4.],
[ 0., 1.],
[ 9., 0.],
[ 0., 0.]]), array([[ 0., 4.],
[ 1., 1.],
[ 0., 4.],
[ 1., 6.]]), array([[ 9., 7.],
[ 0., 9.],
[ 6., 1.],
[ 3., 0.]])]
直接把一个数组赋值给另一个数组，两个数组指向同一片内存区域，对其中一个的操作就会影响另一个结果
a = np.arange(12)
b = a #a和b是同一个数组对象的两个名字
print (b is a)
b.shape = 3,4
print (a.shape)
print (id(a)) #id表示指向内存区域，具有相同id，表示a、b指向相同内存区域中的值
print (id(b))
输出结果：
True
(3, 4)
4382560048
4382560048
view方法创建一个新数组，指向的内存区域不同，但元素值共用
import numpy as np
a = np.arange(12)
c = a.view()
print(id(a)) #id值不同
print(id(c))
print(c is a)
c.shape = 2,6
print (a.shape) #改变c的shape，a的shape不变
c[0,4] = 1234 #改变c中元素的值
print(a) #a中元素的值也会发生改变
输出结果：
4382897216
4382897136
False
(12,)
[ 0 1 2 3 1234 5 6 7 8 9 10 11]
copy方法(深复制)创建一个对数组和元素值的完整的copy
d = a.copy()
按照矩阵的行列找出最大值，最大值的索引
import numpy as np
data = np.sin(np.arange(20)).reshape(5,4)
print (data)
ind = data.argmax(axis=0) #找出每列最大值的索引
print (ind)
data_max = data[ind, range(data.shape[1])] #通过行列索引取值
print (data_max)
输出结果：
[[ 0. 0.84147098 0.90929743 0.14112001]
[-0.7568025 -0.95892427 -0.2794155 0.6569866 ]
[ 0.98935825 0.41211849 -0.54402111 -0.99999021]
[-0.53657292 0.42016704 0.99060736 0.65028784]
[-0.28790332 -0.96139749 -0.75098725 0.14987721]]
[2 0 3 1]
[ 0.98935825 0.84147098 0.99060736 0.6569866 ]
tile方法，对原矩阵的行列进行扩展
import numpy as np
a = np.arange(0, 40, 10)
b = np.tile(a, (2, 3)) #行变成2倍，列变成3倍
print(b)
输出结果：
[[ 0 10 20 30 0 10 20 30 0 10 20 30]
[ 0 10 20 30 0 10 20 30 0 10 20 30]]
两种排序方法
sort方法对矩阵中的值进行排序，argsort方法得到元素从小到大的索引值，根据索引值的到排序结果
a = np.array([[4, 3, 5], [1, 2, 1]])
b = np.sort(a, axis=1) #对a按行由小到大排序，值赋给b
print(b)
a.sort(axis=1) #直接对a按行由小到大排序
print(a)
a = np.array([4, 3, 1, 2])
j = np.argsort(a) #argsort方法得到元素从小到大的索引值
print (j)
print (a[j]) #根据索引值输出a
输出结果：
[[3 4 5]
[1 1 2]]
-------
[[3 4 5]
[1 1 2]]
-------
[2 3 1 0]
-------
[1 2 3 4]
数据分析处理库Pandas，基于Numpy
read_csv方法读取csv文件
import pandas as pd
food_info = pd.read_csv("food_info.csv")
print(type(food_info)) #pandas代表的DataFrame可以当成矩阵结构
print(food_info.dtypes) #dtypes在当前数据中包含的数据类型
输出结果：
<class 'pandas.core.frame.DataFrame'>
NDB_No int64
Shrt_Desc object
Water_(g) float64
Energ_Kcal int64
......
Cholestrl_(mg) float64
dtype: object
获取读取到的文件的信息
print(food_info.head(3)) #head()方法如果没有参数，默认获取前5行
print(food_info.tail()) #tail()方法获取最后5行
print(food_info.columns) #columns获取所有的列名
print(food_info.shape) #获取当前数据维度(8618, 36)
取出指定某行的数据
print(food_info.loc[0]) #取出第零行的数据
food_info.loc[8620] # 当index值超过最大值，throw an error: "KeyError: 'the label [8620] is not in the [index]'"
food_info.loc[3:6] #取出第三到第六行数据，3、4、5、6
two_five_ten = [2,5,10]
food_info.loc[two_five_ten] #取出第2、5、10行数据
取出指定某列的数据
ndb_col = food_info["NDB_No"] #取出第一列NDB_No中的数据
print (ndb_col)
columns = ["Zinc_(mg)", "Copper_(mg)"] #要取出多列，就写入所要取出列的列名
zinc_copper = food_info[columns]
print(zinc_copper)
取出以(g)为结尾的列名
col_names = food_info.columns.tolist() #tolist()方法将列名放在一个list里
gram_columns = []
for c in col_names:
if c.endswith("(g)"):
gram_columns.append(c)
gram_df = food_info[gram_columns]
print(gram_df.head(3))
输出结果：
Water_(g) Protein_(g) Lipid_Tot_(g) Ash_(g) Carbohydrt_(g) \
0 15.87 0.85 81.11 2.11 0.06
1 15.87 0.85 81.11 2.11 0.06
2 0.24 0.28 99.48 0.00 0.00
3 42.41 21.40 28.74 5.11 2.34
4 41.11 23.24 29.68 3.18 2.79
Fiber_TD_(g) Sugar_Tot_(g) FA_Sat_(g) FA_Mono_(g) FA_Poly_(g)
0 0.0 0.06 51.368 21.021 3.043
1 0.0 0.06 50.489 23.426 3.012
2 0.0 0.00 61.924 28.732 3.694
3 0.0 0.50 18.669 7.778 0.800
4 0.0 0.51 18.764 8.598 0.784
对某列中的数据进行四则运算
import pandas
food_info = pandas.read_csv("food_info.csv")
iron_grams = food_info["Iron_(mg)"] / 1000 #对列中的数据除以1000
food_info["Iron_(g)"] = iron_grams #新增一列Iron_(g) 保存结果
water_energy = food_info["Water_(g)"] * food_info["Energ_Kcal"] #将两列数字相乘
求某列中的最大值、最小值、均值
max_calories = food_info["Energ_Kcal"].max()
print(max_calories)
min_calories = food_info["Energ_Kcal"].min()
print(min_calories)
mean_calories = food_info["Energ_Kcal"].mean()
print(mean_calories)
输出结果：
902
0
226.438616848
使用sort_values()方法对某列数据进行排序
food_info.sort_values("Sodium_(mg)", inplace=True)
#默认从小到大排序，inplace=True表示返回一个新的数据结构，而不在原来基础上做改变
print(food_info["Sodium_(mg)"])
food_info.sort_values("Sodium_(mg)", inplace=True, ascending=False)
#ascending=False表示从大到小排序，
print(food_info["Sodium_(mg)"])
针对titanic_train.csv 的练习（含pivot_table()透视表方法）
import pandas as pd
import numpy as np
titanic_survival = pd.read_csv("titanic_train.csv")
titanic_survival.head()
age = titanic_survival["Age"]
print(age.loc[0:20]) #打印某一列的0到20行
age_is_null = pd.isnull(age) #isnull()方法用于检测是否为缺失值，缺失为True 不缺失为False
print(age_is_null)
age_null_true = age[age_is_null] #得到该列所有缺失的行
print(age_null_true)
age_null_count = len(age_null_true)
print(age_null_count) #缺失的行数
#存在缺失值的情况下无法计算均值
mean_age = sum(titanic_survival["Age"]) / len(titanic_survival["Age"]) #sum()方法对列中元素求和
print(mean_age) #nan
#在计算均值前要把缺失值剔除
good_ages = titanic_survival["Age"][age_is_null == False] #不缺失的取出来
correct_mean_age = sum(good_ages) / len(good_ages)
print(correct_mean_age) #29.6991176471
#当然也可以不这么麻烦，缺失值很普遍，pandas提供了mean()方法用于自动剔除缺失值并求均值
correct_mean_age = titanic_survival["Age"].mean()
print(correct_mean_age) #29.6991176471
#求每个仓位等级，船票的平均价格
passenger_classes = [1, 2, 3]
fares_by_class = {}
for this_class in passenger_classes:
pclass_rows = titanic_survival[titanic_survival["Pclass"] == this_class]
pclass_fares = pclass_rows["Fare"] #定为到同一等级舱，船票价格的那一列
fare_for_class = pclass_fares.mean()
fares_by_class[this_class] = fare_for_class
print(fares_by_class)
运算结果：
{1: 84.154687499999994, 2: 20.662183152173913, 3: 13.675550101832993}
#pandas为我们提供了更方便的统计工具，pivot_table()透视表方法
#index 告诉pivot_table方法是根据哪一列分组
#values 指定对哪一列进行计算
#aggfunc 指定使用什么计算方法
passenger_survival = titanic_survival.pivot_table(index="Pclass", values="Survived", aggfunc=np.mean)
print(passenger_survival)
运算结果：
Pclass Survived
1 0.629630
2 0.472826
3 0.242363
#计算不同等级舱乘客的平均年龄
passenger_age = titanic_survival.pivot_table(index="Pclass", values="Age") #默认采用aggfunc=np.mean计算方法
print(passenger_age)
运算结果：
Pclass Age
1 38.233441
2 29.877630
3 25.140620
#index 根据一列分组
##values 指定对多列进行计算
port_stats = titanic_survival.pivot_table(index="Embarked", values=["Fare","Survived"], aggfunc=np.sum)
print(port_stats)
运算结果：
Embarked Fare Survived
C 10072.2962 93
Q 1022.2543 30
S 17439.3988 217
#丢弃有缺失值的数据行
new_titanic_survival = titanic_survival.dropna(axis=0,subset=["Age", "Cabin"]) #subset指定了Age和Cabin中任何一个有缺失的，这行数据就丢弃
print(new_titanic_survival)
#按照行列定位元素，取出值
row_index_83_age = titanic_survival.loc[103,"Age"]
row_index_1000_pclass = titanic_survival.loc[766,"Pclass"]
print(row_index_83_age)
print(row_index_1000_pclass)
#sort_values()排序，reset_index()重新设置行号
new_titanic_survival = titanic_survival.sort_values("Age",ascending=False) #ascending=False从大到小
print(new_titanic_survival[0:10]) #但序号是原来的序号
itanic_reindexed = new_titanic_survival.reset_index(drop=True) #reset_index(drop=True)更新行号
print(itanic_reindexed.iloc[0:10]) #iloc通过行号获取行数据
#通过定义一个函数，把操作封装起来，然后apply函数
def hundredth_row(column): #这个函数返回第100行的每一列数据
# Extract the hundredth item
hundredth_item = column.iloc[99]
return hundredth_item
hundredth_row = titanic_survival.apply(hundredth_row) #apply()应用函数
print(hundredth_row)
返回结果：
PassengerId 100
Survived 0
Pclass 2
Name Kantor, Mr. Sinai
Sex male
Age 34
SibSp 1
Parch 0
Ticket 244367
Fare 26
Cabin NaN
Embarked S
dtype: object
##统计所有的缺失值
def not_null_count(column):
column_null = pd.isnull(column)
null = column[column_null]
return len(null)
column_null_count = titanic_survival.apply(not_null_count)
print(column_null_count)
输出结果：
PassengerId 0
Survived 0
Pclass 0
Name 0
Sex 0
Age 177
SibSp 0
Parch 0
Ticket 0
Fare 0
Cabin 687
Embarked 2
dtype: int64
#对船舱等级进行转换
def which_class(row):
pclass = row['Pclass']
if pd.isnull(pclass):
return "Unknown"
elif pclass == 1:
return "First Class"
elif pclass == 2:
return "Second Class"
elif pclass == 3:
return "Third Class"
classes = titanic_survival.apply(which_class, axis=1) #通过axis = 1参数，使用DataFrame.apply（）方法来迭代行而不是列。
print(classes)
#使用两个自定义函数，统计不同年龄标签对应的存活率
def generate_age_label(row):
age = row["Age"]
if pd.isnull(age):
return "unknown"
elif age < 18:
return "minor"
else:
return "adult"
age_labels = titanic_survival.apply(generate_age_label, axis=1)
titanic_survival['age_labels'] = age_labels
age_group_survival = titanic_survival.pivot_table(index="age_labels", values="Survived" ,aggfunc=np.mean)
print(age_group_survival)
运算结果：
age_labels Survived
adult 0.381032
minor 0.539823
unknown 0.293785
Series结构
Series (collection of values) DataFrame中的一行或者一列就是Series结构
DataFrame (collection of Series objects)是读取文件read_csv()方法获得的矩阵
Panel (collection of DataFrame objects)
import pandas as pd
fandango = pd.read_csv('fandango_score_comparison.csv') #读取电影信息，DataFrame结构
series_film = fandango['FILM'] #定位到“FILM”这一列
print(type(series_film)) #<class 'pandas.core.series.Series'>结构
print(series_film[0:5]) #通过索引切片
series_rt = fandango['RottenTomatoes']
print (series_rt[0:5])
from pandas import Series # Import the Series object from pandas
film_names = series_film.values #把Series结构中的每一个值拿出来
print(type(film_names)) #<class 'numpy.ndarray'>说明series结构中每一个值的结构是ndarray
rt_scores = series_rt.values
series_custom = Series(rt_scores , index=film_names) #设置以film_names为索引的film结构,创建一个Series
series_custom[['Minions (2015)', 'Leviathan (2014)']] #确实可以使用名字索引
fiveten = series_custom[5:10] #也可以使用数字索引
print(fiveten)
Series中的排序
original_index = series_custom.index.tolist() #将index值放入一个list结构中
sorted_index = sorted(original_index)
sorted_by_index = series_custom.reindex(sorted_index) #reset index操作
print(sorted_by_index)
sc2 = series_custom.sort_index() #根据index值进行排序
sc3 = series_custom.sort_values() #根据value值进行排序
print(sc3)
在Series中的每一个值的类型是ndarray，即NumPy中核心数据类型
import numpy as np
print(np.add(series_custom, series_custom)) #将两列值相加
np.sin(series_custom) #对每个值使用sin函数
np.max(series_custom) #获取某一列的最大值
取出series_custom列中数值在50到70之间的数值
对某一列中的所有值进行比较运算，返回boolean值
criteria_one = series_custom > 50
criteria_two = series_custom < 75
both_criteria = series_custom[criteria_one & criteria_two] #返回boolean值的Series对象
print(both_criteria)
对index相同的两列运算
#data alignment same index
rt_critics = Series(fandango['RottenTomatoes'].values, index=fandango['FILM'])
rt_users = Series(fandango['RottenTomatoes_User'].values, index=fandango['FILM'])
rt_mean = (rt_critics + rt_users)/2
print(rt_mean)
对DataFrame结构进行操作
设置‘FILM’为索引
fandango = pd.read_csv('fandango_score_comparison.csv')
print(type(fandango)) #<class 'pandas.core.frame.DataFrame'>
fandango_films = fandango.set_index('FILM', drop=False)
#以‘FILM’为索引返回一个新的DataFrame ，drop=False不丢弃原来的FILM列
对DataFrame切片
#可以使用[]或者loc[]来切片
fandango_films["Avengers: Age of Ultron (2015)":"Hot Tub Time Machine 2 (2015)"] #用string值做的索引也可以切片
fandango_films.loc["Avengers: Age of Ultron (2015)":"Hot Tub Time Machine 2 (2015)"]
fandango_films[0:3] #数值索引依然存在，可以用来切片
#选择特定的列
#movies = ['Kumiko, The Treasure Hunter (2015)', 'Do You Believe? (2015)', 'Ant-Man (2015)']
可视化库matplotlib
Matplotlib是Python中最常用的可视化工具之一，可以非常方便地创建海量类型地2D图表和一些基本的3D图表。
2D图表之折线图
Matplotlib中最基础的模块是pyplot，先从最简单的点图和线图开始。
更多属性可以参考官网：http://matplotlib.org/api/pyplot_api.html
import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt
unrate = pd.read_csv('unrate.csv')
unrate['DATE'] = pd.to_datetime(unrate['DATE']) #pd.to_datetime方法标准化日期格式
first_twelve = unrate[0:12] #取0到12行数据
plt.plot(first_twelve['DATE'], first_twelve['VALUE']) #plot(x轴,y轴)方法画图
plt.xticks(rotation=45) #设置x轴上横坐标旋转角度
plt.xlabel('Month') #x轴含义
plt.ylabel('Unemployment Rate') #y轴含义
plt.title('Monthly Unemployment Trends, 1948') #图标题
plt.show() #show方法显示图
子图操作
添加子图：add_subplot(first,second,index)
first 表示行数,second 列数.
import matplotlib.pyplot as plt
fig = plt.figure() #Creates a new figure.
ax1 = fig.add_subplot(3,2,1) #一个3*2子图中的第一个模块
ax2 = fig.add_subplot(3,2,2) #一个3*2子图中的第二个模块
ax2 = fig.add_subplot(3,2,6) #一个3*2子图中的第六个模块
plt.show()
import numpy as np
#fig = plt.figure()
fig = plt.figure(figsize=(3, 6)) #指定画图区大小（长，宽）
ax1 = fig.add_subplot(2,1,1)
ax2 = fig.add_subplot(2,1,2)
ax1.plot(np.random.randint(1,5,5), np.arange(5)) #第一个子图画图
ax2.plot(np.arange(10)*3, np.arange(10)) #第二个子图画图
plt.show()
在同一个图中画两条折线（plot两次）
fig = plt.figure(figsize=(6,3))
plt.plot(unrate[0:12]['MONTH'], unrate[0:12]['VALUE'], c='red')
plt.plot(unrate[12:24]['MONTH'], unrate[12:24]['VALUE'], c='blue')
plt.show()
为所画曲线作标记
fig = plt.figure(figsize=(10,6))
colors = ['red', 'blue', 'green', 'orange', 'black']
for i in range(5):
start_index = I*12
end_index = (i+1)*12
subset = unrate[start_index:end_index]
label = str(1948 + i) #label值
plt.plot(subset['MONTH'], subset['VALUE'], c=colors[i], label=label) #x轴指标，y轴指标，颜色，label值
plt.legend(loc='upper left') #loc指定legend方框的位置,loc = 'best'/'upper right'/'lower left'等，print(help(plt.legend))查看用法
plt.xlabel('Month, Integer')
plt.ylabel('Unemployment Rate, Percent')
plt.title('Monthly Unemployment Trends, 1948-1952')
plt.show()
2D图标之条形图与散点图
bar条形图
import pandas as pd
reviews = pd.read_csv('fandango_scores.csv') #读取电影评分表
cols = ['FILM', 'RT_user_norm', 'Metacritic_user_nom', 'IMDB_norm', 'Fandango_Ratingvalue', 'Fandango_Stars']
norm_reviews = reviews[cols]
num_cols = ['RT_user_norm', 'Metacritic_user_nom', 'IMDB_norm', 'Fandango_Ratingvalue', 'Fandango_Stars']
bar_heights = norm_reviews.ix[0, num_cols].values #柱高度
bar_positions = arange(5) + 0.75 #设定每一个柱到左边的距离
tick_positions = range(1,6) #设置x轴刻度标签为[1,2,3,4,5]
fig, ax = plt.subplots()
ax.bar(bar_positions, bar_heights, 0.5) #bar型图。柱到左边距离，柱高度，柱宽度
ax.set_xticks(tick_positions) #x轴刻度标签
ax.set_xticklabels(num_cols, rotation=45)
ax.set_xlabel('Rating Source')
ax.set_ylabel('Average Rating')
ax.set_title('Average User Rating For Avengers: Age of Ultron (2015)')
plt.show()
散点图
fig, ax = plt.subplots() #fig控制图的整体情况，如大小，用ax实际来画图
ax.scatter(norm_reviews['Fandango_Ratingvalue'], norm_reviews['RT_user_norm']) #scatter方法，画散点图的x轴，y轴
ax.set_xlabel('Fandango')
ax.set_ylabel('Rotten Tomatoes')
plt.show()
散点图子图
fig = plt.figure(figsize=(8,3))
ax1 = fig.add_subplot(1,2,1)
ax2 = fig.add_subplot(1,2,2)
ax1.scatter(norm_reviews['Fandango_Ratingvalue'], norm_reviews['RT_user_norm'])
ax1.set_xlabel('Fandango')
ax1.set_ylabel('Rotten Tomatoes')
ax2.scatter(norm_reviews['RT_user_norm'], norm_reviews['Fandango_Ratingvalue'])
ax2.set_xlabel('Rotten Tomatoes')
ax2.set_ylabel('Fandango')
plt.show()
屏幕快照 2017-11-05 上午11.42.10.png
网友评论