推荐系统-Python语言及数据科学库基础(三)_pandas数据处理,数据如下 height,house,car,handsome,job,is_d

机器学习语言必备-数据科学必备库

1.Pandas介绍

• Pandas的名称来自于panel data(面板数据)和Python数据分析(data analysis)，Pandas是处理结构化数据的利器，利用python数据以及数据结构完成对结构化数据的处理和分析功能。
• 特点
  • 1.一个强大的分析和操作大型**结构化数据集**所需的工具集
  • 2.基础是NumPy，提供了高性能矩阵的运算
  • 3.提供了大量能够快速便捷地处理数据的函数和方法
  • 4.应用于数据挖掘，数据分析
  • 5.提供数据清洗功能(缺失值的填充 , 均值的填充)
• Pandas有两个最主要也是最重要的数据结构： Series和 DataFrame

2.Series数据结构详解

• Series是一种类似于一维数组的对象 , 由一组数据(各种numpy数据类型)以及组与之对应的缩影(数据标签)组成
• Series=index：value
• 字典非常适合做Series类型
• 根据index完成value的值的打印
• 创建：可以根据list、tuple、dict、set等方式进行创建，指定index的值，查询的时候根据index查询value的值，删除和更新的操作也是使用index查询value的值。
• 属性：
  • shape、index、values、head、unique、size、dtype属性或函数

import pandas as pd
#使用pandas
#1.创建
s1=pd.Series([1,2,3,4],index=("a","b","c","d"))
s2=pd.Series({"a":1,"b":2,"c":3,"d":4})
print(s2)
print(":"*100)
print(s1)#显示索引 , 数据和dtype
print(type(s1)) #<class 'pandas.core.series.Series'> 
#2.查询
print(s1["a"])
#3.更改
s1["a"]=100
print(s1)

#4.属性信息打印
print(s2.index) #Index(['a', 'b', 'c', 'd'], dtype='object')
print(s2.values) #[1 2 3 4]
print(s2.shape) #(4,)
print(s2.ndim) #1
print(s2.size) #4
print(s2.dtype) #int64
print(s2.head()) #前5行数据获取
s2.index.name="ok"
print(s2)
# ok
# a    1
# b    2
# c    3
# d    4
# dtype: int64
print(s2.index.name)
s2.name="hello"
# value没有name属性
print(s2)
# ok
# a    1
# b    2
# c    3
# d    4
# Name: hello, dtype: int64

s3=pd.Series([-1,-2,3,-1,-4,3,0,0,1])
print(s3)
print(s3.unique()) #[-1 -2  3 -4  0  1] 仅仅只做去重
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

3.Pandas-DataFrame详解

• dataframe是数据框？ ===> DataFrame是一个表格型的数据结构，它含有一组有序的列，每列可以是不同类型的值。DataFrame既有行索引也有列索引，它可以被看做是由Series组成的字典（共用同一个索引），数据是以二维结构存放的。

  • 1.类似多维数组/表格数据 (如，excel, R中的data.frame)
  • 2.每列数据可以是不同的类型
  • 3.索引包括列索引和行索引

• dataFrame是处理二维以上数据组织形式

• pd.DataFrame方式进行定义，指定行row或列columns

• 增删改查部分操作

• iloc和loc方法(掌握)

  • iloc-index(索引值)
  • loc直接根据列名和行的名字进行打印

• 总结：可以输入给DataFrame构造器数据的有如下类型：

  （1）二维ndarry

  （2）由数组、列表、元祖组成的字典

  （3）由Series组成的字典

  （4）由字典组成的字典

  （5）另外一个DataFrame

import pandas as pd
df1=pd.DataFrame([[1,2,3],[4,5,6],[7,8,9]],index=("a","b","c"),columns=("A","B","C"))
print(df1)
#    A  B  C
# a  1  2  3
# b  4  5  6
# c  7  8  9
import  numpy as np
df2=pd.DataFrame(np.random.randn(4,4),index=("a","b","c","d"),columns=("A","B","C","D"))
print(df2)
#属性信息
print(df1.shape)
print(df1.head(1))
print(df1.ndim)
print(df1.info())# 重要属性
print(df1.columns) #Index(['A', 'B', 'C'], dtype='object')
print(df1.index) #Index(['a', 'b', 'c'], dtype='object')
# <class 'pandas.core.frame.DataFrame'>
# Index: 3 entries, a to c
# Data columns (total 3 columns):
# A    3 non-null int64 
# B    3 non-null int64
# C    3 non-null int64
# dtypes: int64(3)
# memory usage: 96.0+ bytes
#查询
print(df1["A"]) #通过[]指定对应的列信息
print("::"*100)
print(df1.A) # 获取某一列的值
print("::"*100)
print(df1.ix["a","A"])
print(df1.ix[:,"A"])
print(df1.ix["a",:])
print(df1.ix[:,:])
print("::"*100)
# loc属性取得的行列名称对应的值
print(df1.loc[:,"A"])
print(df1.loc["a",:])
print(df1.loc[:,:])
print("::"*100)
# iloc是根据索引值获取
print(df1.iloc[0,0])
print(df1.iloc[:,0])
print(df1.iloc[0,:])
print("+"*100)
print(df1.iloc[0:2]) # iloc索引中包头不包尾
#    A  B  C
# a  1  2  3
# b  4  5  6
print(df1.iloc[0:2,0:2])
print(df1.loc["a":"c"]) # loc中包头包尾
print(df1.loc["a":"b"])
print(df1.loc["a":"b","A":"B"])
print(df1.loc[:, lambda df: ['A', 'B']]) # df表示变量
print("+"*100)
# 日期操作
import pandas as pd
import numpy as np
df=pd.DataFrame(np.random.randn(5,4),cloumns=list('ABCD'),index=pd.data_range('20190101',period=5))#period=5表示向后5天
print(df)
#                    A         B         C         D
# 2013-01-01  1.075770 -0.109050  1.643563 -1.469388
# 2013-01-02  0.357021 -0.674600 -1.776904 -0.968914
# 2013-01-03 -1.294524  0.413738  0.276662 -0.472035
# 2013-01-04 -0.013960 -0.362543 -0.006154 -0.923061
# 2013-01-05  0.895717  0.805244 -1.206412  2.565646
print(dfl.loc['20130102':'20130104'])
print(dfl.loc['20130102':'20130104'])
print(dfl.loc['20130102':'20130104',"A":"C"])
#更改
df1.ix["a","A"]=100
print(df1)
#删除操作
#不能指定删除行和某一特定值 , 不支持迭代删除
del df1["A"]
print(df1)
#增加一列
df1["D"]=[1,2,3]
print(df1)
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
79

补充 :

#补充1：索引对象是不可以修改的：如
obj=Series(range(3),index=['a','b','c'])
index=obj.index
print(index)
print(index[1:])
index[1]='d' #会报错
这个用法会保证index对象在多个数据结构之间安全共享。
#补充2：pandas对象重新索引
obj=Series(range(3),index=['a','b','c'])
obj2=obj.reindex(['c','a','b','f'])
obj3=obj.reindex(['c','a','b','f'],fill_value=0)
obj4=obj.reindex(['c','a','b','f'],method='ffill')
method可选：
	#ffill或pad前向填充值
	#bfill或backfill 后向填充值
#补充3：丢弃指定轴上的项,按照索引删除
obj=Series(range(3),index=['a','b','c'])
new_obj=obj.drop('c')
print(new_obj)
new_obj2=obj.drop(['a','b'])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

4.Pandas的对齐运算

• 对齐运算是数据清洗的重要过程，可以按索引对齐进行运算，如果没对齐的位置则补NaN，最后也可以填充NaN
• 对齐操作，对于多个值的求和或加减乘除问题的求解方法
• add(变量，fill_value)
• 对于Series和DataFrame均适用

import  pandas as pd
s1=pd.Series(data=range(5),index=range(5))
s2=pd.Series(data=range(10),index=range(10))
print(s1+s2)
print(s1.add(s2,fill_value=100))
import numpy as np
df1=pd.DataFrame(data=np.ones((2,2)),columns=("a","b"))
df2=pd.DataFrame(data=np.ones((3,3)),columns=("a","b","c"))
print(df1+df2)
print(df1.add(df2,fill_value=100))
1
2
3
4
5
6
7
8
9
10

5.Pandas的函数应用

• fillna : 将nan转换为指定值
• dropna : 删除含有nan的(行(0)/列(1))
• isnull : 判断是否为空 , 空位true , 非空为false
• drop(labels，axis=0 or1)
• pandas:sort_index 索引排序
• pandas:value_index 索引排序

import pandas as pd
import  numpy as np
print(np.random.randn(3))
df1=pd.DataFrame([np.random.randn(3),[np.nan,2,2],[1,np.nan,3]],
                 columns=("A","B","C"),index=("a","b","c"))
print(df1)
#isnull
print(df1.isnull())
#fillna
print(df1.fillna(100))
#dropna
print(df1.dropna(axis=0))# 删除含有nan的行
#          0         1         2
# 0 -0.85841 -0.647983 -1.414457
print(df1.dropna(axis=1))# 删除含有nan的列
#           2
# 0 -1.414457
# 1  2.000000
# 2  3.000000
# drop操作- Drop specified labels from rows or columns.
import pandas as pd
import  numpy as np
print(np.random.randn(3))
df1=pd.DataFrame([np.random.randn(3),[np.nan,2,2],[1,np.nan,3]],
                 columns=("A","B","C"),index=("a","b","c"))
print(df1.drop(["A"],axis=1))
# print(df1.drop([0]))
print(df1.drop(["a"]))
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

6.层次索引

• 指定多层索引
• 如何查询，df [外层索引][内层索引]
• 如何交换内外层索引：swaplevel
• 如何进行索引重排序：sortlevel

import  pandas as pd
import numpy as np
s1=pd.Series(np.random.randn(12),
          index=[["a","a","a","b","b","b","c","c","c","d","d","d"],
                 [1,2,3,1,2,3,1,2,3,1,2,3]])
print(s1)
print(s1["a"][1])
s1["a"][1]=100
print(s1)
#两个index的互换
print(s1.swaplevel())
#两个index的互换且排序
print(s1.swaplevel().sortlevel())
1
2
3
4
5
6
7
8
9
10
11
12
13

7.Pandas统计计算和描述

• describtion描述信息
  • count
  • min
  • max
  • std
  • var
• 统计计算一定需要按照行or列进行计算
• 正态分布的偏度为0 ; 正态分布的峰度为3
• query等函数的用法 : http://pandas.pydata.org/pandas-docs/version/0.18/api.html

import pandas as pd
import numpy as np
df1=pd.DataFrame(np.random.randn(5,4),index=("a","b","c","d","e"),
                 columns=("A","B","C","D"))
print(df1)
# sum, mean, max, min… axis = 0
# 按行统计，axis = 1
# 按列统计，axis = 0
# skipna 排除缺失值， 默认为True
print(df1.sum(axis=1))
print(df1.sum(axis=0))
print(df1.mean(axis=1))
print(df1.mean(axis=0))
print(df1.max(axis=0))
#description描述信息
print(df1.describe())
#               A         B         C         D
# count  5.000000  5.000000  5.000000  5.000000  有几个样本数据
# mean  -0.196643  0.510580 -0.076933  0.144531  均值
# std    0.759045  0.882974  0.542685  1.179448  标准差
# min   -1.342553 -0.751580 -0.815040 -1.210786  最小值
# 25%   -0.460303  0.352631 -0.388602 -0.983421  1/4分位数
# 50%   -0.137811  0.460187  0.049356  0.623713  中位数
# 75%    0.422771  0.789292  0.168337  0.816850  3/4分位数
# max    0.534681  1.702369  0.601287  1.476297  最大值
print(df1)
# query表示条件查询(布尔表达式)
print(df1.query("A>B"))

#
# count 非Nan数量
print(df1.count())
# describe 针对各个列汇总统计
# min和max 最大最小值
# argmin、argmax 计算最大值或最小值对应的索引位置
# print(df1.argmin(axis=0))
# quantile 计算样本的分位数（0-1） 
print(df1.quantile(0.65))
# mean 均值
print(df1.mean(axis=0))
# median 中位数
# mad 平均绝对离差
# var 样本方差
# std 样本的标准差
# skew 样本值的偏度----正态分布的偏度为0 ---- 样本的3阶矩
# kurt 样本值的峰度------正态分布的峰度为3 ---- 样本的4阶矩
# cumsum样本值的累计和
print(df1.cumsum())
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

8.Pandas读取文件（掌握）

• Pandas读取文件函数pd.read_csv(file,sep="")
• 对数据采用基础属性信息查看
• ndim、shape、dtype、info()
• 数据处理—ix\iloc\loc\drop\ …

import pandas as pd
file=pd.read_csv("./SklearnTest.txt")
print(file)
#1.取出height列
print(file["height"])
print(file.height)
#2.取出heigt和house两列
# ix已经过时了
print(file.ix[:,"height":"house"])
print(file.iloc[:,0:2])
print(file.loc[:,"height":"house"])
#3.取出样本数据0-5行样本数据
print(file.iloc[0:6,:])
print(file.loc[0:6,:])
#4.选择特征列和列别标签列
X1=file.ix[:,"height":"job"]
print(X1)
print(type(X1))
Y1=file.ix[:,"is_date"]
print(Y1)
print(type(Y1)) #<class 'pandas.core.series.Series'>
# 选择需要的列
print(file[["height","car"]])
#5.选择is_date=
new_Date=file.query("is_date==-1")
data=file.query("is_date!=-1")
print(new_Date)
#    height  house  car  handsome  job  is_date
# 8    1.65      0    1       6.6    0       -1
print(data)
#    height  house  car  handsome  job  is_date
# 0    1.80      1    0       6.5    2        1
# 1    1.62      1    0       5.5    0        1
# 2    1.71      0    1       8.5    1        1
# 3    1.58      1    1       6.3    1        1
# 4    1.68      0    1       5.1    0        0
# 5    1.63      1    0       5.3    1        0
# 6    1.78      0    0       4.5    0        0
# 7    1.64      0    0       7.8    2        0
#6.将data已经处理好的数据分为X和y
X=data.iloc[:,0:5]
y=data.iloc[:,5]
print(X)
print(type(X)) #<class 'pandas.core.frame.DataFrame'>
print(y)
print(type(y)) #<class 'pandas.core.series.Series'>

X=data.drop("is_date",axis=1)
print(X)
print(type(X)) #<class 'pandas.core.frame.DataFrame'>
# data["is_date"]
# data.is_date
# data.ix
# data.iloc
# data.loc

X.to_csv("result.txt",sep=",")
datafile=pd.read_csv("result.txt")
print(datafile)
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

9.Pandas函数补充(1)

• to_pickle（）转化为pickle文件

import pandas as pd
original_df = pd.DataFrame({"foo": range(5), "bar": range(5, 10)})
print(original_df)
pd.to_pickle(original_df, "./dummy.pkl")
unpickled_df = pd.read_pickle("./dummy.pkl")
print(unpickled_df)
1
2
3
4
5
6

• cut对连续型数值离散化

import numpy as np
import pandas as pd
print(pd.cut(np.array([.2, 1.4, 2.5, 6.2, 9.7, 2.1]), 3, retbins=True))
# (0.19, 3.367],(3.367, 6.533], (6.533, 9.7]
# ([(0.191, 3.367], (0.191, 3.367], (0.191, 3.367], (3.367, 6.533],
#   (6.533, 9.7], (0.191, 3.367]]
# Categories (3, object): [(0.191, 3.367] < (3.367, 6.533] < (6.533, 9.7]],
# array([ 0.1905    ,  3.36666667,  6.53333333,  9.7       ]))
pd.cut(np.array([.2, 1.4, 2.5, 6.2, 9.7, 2.1]), 3,
           labels=["good","medium","bad"])
# [good, good, good, medium, bad, good]
# Categories (3, object): [good < medium < bad]
pd.cut(np.ones(5), 4, labels=False)
# array([1, 1, 1, 1, 1], dtype=int64)
print(pd.qcut(range(5), 3, labels=["good", "medium", "bad"]))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• concat方法按照行或列进行合并

import pandas as pd
s1 = pd.Series(['a', 'b'])
s2 = pd.Series(['c', 'd'])
print(s1)
print(s2)
print(pd.concat([s1, s2],axis=0))
print(pd.concat([s1, s2],axis=1))

import numpy as np
df1 = pd.DataFrame([['a', 1], ['b', 2]],columns = ['letter', 'number'])
print(df1)
df2 = pd.DataFrame([['c', 3], ['d', 4]],columns = ['letter', 'number'])
print(df2)
print(pd.concat([df1, df2],ignore_index=True))
print(pd.concat([df1, df2],ignore_index=True,axis=1))
# print(np.vstack((df1,df2)))
# print(np.hstack((df1,df2)))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• onehot编码

#one-hot编码形式
import pandas as pd
s = pd.Series(list('abca'))
print(s)
# 0    a
# 1    b
# 2    c
# 3    a
pd.get_dummies(s)
#    a  b  c
# 0  1  0  0
# 1  0  1  0
# 2  0  0  1
# 3  1  0  0
df = pd.DataFrame({'A': ['a', 'b', 'a'], 'B': ['b', 'a', 'c'],
                    'C': [1, 2, 3]})
print(df)
#    A  B  C
# 0  a  b  1
# 1  b  a  2
# 2  a  c  3
print(pd.get_dummies(df, prefix=['col1', 'col2']))
# prefix前缀:字符串,字符串,列表或dict的字符串,默认没有字符串附
# 加数据帧通过列名列表长度等于列数当调用数据帧上的。
# 另外,“前缀”可以是一个字典映射列名称前缀。
#    C     col1_a  col1_b col2_a  col2_b  col2_c
# 0  1       1       0       0       1       0
# 1  2       0       1       1       0       0
# 2  3       1       0       0       0       1

# pd.factorize()
# #实现说明:该方法负责3 #
# #  1)强迫数据数组类(ndarray、索引扩展数组)
# #  2)分解标签和--物品
# #  3)也许索引中的输出
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

• to_numberic函数

import pandas as pd
s = pd.Series(['1.0', '2', -3])
print(pd.to_numeric(s))
s = pd.Series(['apple', '1.0', '2', -3])
# print(pd.to_numeric(s))
print(pd.to_numeric(s, errors='ignore'))
print(pd.to_numeric(s, errors='coerce'))
1
2
3
4
5
6
7

10.Pandas函数补充(2)

• 聚合操作

  print(data.groupby(by=["one"])["two"].mean()) #等价写法
  print(data["two"].groupby(by=data["one"]).mean())
  1
  2

#homework-学习groupy用法
# data.groupby(func, axis=0).mean()
# data.groupby(['col1', 'col2'])['col3'].mean()
import pandas as pd
data=pd.DataFrame([[1,2,3],[1,3,3],[4,5,6],[4,3,6]],columns=["one","two","three"])
print(data)
#    one  two  three
# 0    1    2      3
# 0    1    3      3
# 1    4    5      6
# 1    4    3      6
print(data.groupby(by=["one"])["two"])
# <pandas.core.groupby.groupby.SeriesGroupBy object at 0x0000003EDB248748>
print(data.groupby(by=["one"])["two"].mean())
# one
# 1    2.5
# 4    4.0
# Name: two, dtype: float64
print(data.groupby(by=["one"])["two"].mean())
# one
# 1    2.5
# 4    4.0
# Name: two, dtype: float64
#等价写法
print(data["two"].groupby(by=data["one"]).mean())
# print(data.groupby(['one', 'two']).mean())
# one
# 1    2.5
# 4    4.0
# Name: two, dtype: float64
import numpy as np
#根据one列进行聚合，在对其余列进行求解均值
print(data.groupby(['one']).mean())
#      two  three
# one
# 1    2.5    3.0
# 4    4.0    6.0
print("=="*100)
#根据one列进行聚合，在对其余列进行求解均值
print(data.groupby(["one"]).transform(lambda x:np.mean(x)))
#    two  three
# 0  2.5    3.0
# 1  2.5    3.0
# 2  4.0    6.0
# 3  4.0    6.0
print(data.groupby(["one"]).transform(lambda x:(x-np.mean(x))/(np.std(x))))
#    two  three
# 0 -1.0    NaN
# 1  1.0    NaN
# 2  1.0    NaN
# 3 -1.0    NaN
print("=="*100)
#根据one列进行聚合，在对指定列进行求解均值，如”two“
print(data.groupby(["one"]).apply(lambda data:np.mean(data["two"])))
# one
# 1    2.5
# 4    4.0
# dtype: float64


df = pd.DataFrame(np.random.randn(3, 3),columns=["a","b","c"],dtype="int32")
# >>> df
#     0         1          2
# 0  -0.029638  1.081563   1.280300
# 1   0.647747  0.831136  -1.549481
# 2   0.513416 -0.884417   0.195343
# df = df.applymap(lambda x: '%.2f' % x)
# print(df)
# apply让方程作用在一维的向量上时，可以使用apply来完成
# 使用apply应用行或列数据
# print(df.apply(lambda x:x.max(),axis=0))
# 默认axis=0 , 方向是列 ; axis=1 , 方向是行
# applymap让方程作用于DataFrame中的每一个元素，可以使用applymap()
# df1 = df.applymap(lambda x: x.max())
# print(df1)
print("****************************")
# df
#     0         1          2
# 0  -0.03      1.08       1.28
# 1   0.65      0.83      -1.55
# 2   0.51     -0.88       0.20

# df2=df.drop(["a"],axis=1)
df2=df.drop("a",axis=1)
print(df2)
#    b  c
# 0  0  0
# 1  0 -1
# 2  0  0
df3=pd.DataFrame(np.random.randn(3, 3),columns=["a","b","c"],index=["one","two","three"])
print(df3)
#               a         b         c
# one    1.022522 -2.295879  0.052196
# two   -1.263835 -1.057730  0.335293
# three  0.517390  1.520645 -0.881983
df4=df3.reindex(["three","two","one"])
print(df4)
#               a         b         c
# three  0.517390  1.520645 -0.881983
# two   -1.263835 -1.057730  0.335293
# one    1.022522 -2.295879  0.052196

# df4.select("two")
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

11.Pandas函数补充(3)

• 总结：
  • 总结Pandas的基本语法
  • 读取数据
  • 对数据进行处理
  • 保存回到原地

12.Pandas函数补充(5)

13.Pandas数据处理案例一个简单的电影推荐系统

• 推荐系统之前数据预处理

# 获取数据
import pandas as pd

# 电影数据集
movies_data = pd.read_csv('movies.cav')
# 评分数据集
ratings_data = pd.read_csv('ratings.cav')
# 查看数据
print(movies_data)
print(ratings_data)
# 合并数据
data = pd.merge(movies_data, ratings_data)
# 删除列 , 无影响
data.drop('timestamp', 1, inplace=True)
# 查看评价最多的20部电影
data.title.value_counts()[:20]
# 评价最高的电影
import numpy as np

# size是每部电影参评人数 , mean是平均数
movies_ratings = data.groupby('title').agg({'rating': [np.size, np.mean]})
movies_ratings.head()
# 评分最高的前5名 ---- top5
movies_ratings.sort_value([('rating', 'mean')], ascending=False).head(5)
# 虽然评分是5分，但是……评分只有1人啊，这样绝不是我们想看到的，因为不是很客观，于是，我们再来改进下
# 把评价人数大于150人的电影找出来，在进行统计：
movies_ratings[movies_ratings['rating']['size'] >= 150].sort_value([('rating', 'mean')], ascending=False).head(5)

# 推荐电影
import re

name = input("Please input the movie name(or keywords): ")
name = name.title()  # 首字母大写
mov = movies_data[movies_data['title'].str.contains(name)]
# 提取电影名字
y = str(mov['genres']).strip('Name: genres, dtype: object').strip()
p = re.compile(r'\D+')
result = p.findall(y)
res = result[0].strip()

movies_lists = movies_data[movies_data['genres'] == res]
movies_lists
# movieId, title, genres
# movieId:每部电影的id
# title:电影的标题
# genres:电影的类别
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

14.Matplotlib&Seaborn数据可视化库

• Matplotlib是2D绘图库
• Seaborn是Maplotlib的上层的绘图库，只需要执行几行代码就可以执行
• import matplotlib.pyplot as plt
• plt.plot绘制直线图或折线图
• plt.show()进行展示图形

import matplotlib.pyplot as plt
plt.plot([1,2],[2,1])
plt.show()
1
2
3

15.Matplotlib入门案例

• 版本通过__version__进行输出
• 如果需要保存图片话，需要使用savefig直接给定名字绑定
• 如果想使用中文在标题上进行输出，需要指定u"标题内容"，fontproperties="SimHei"

import matplotlib as pl
# 1.打印Matplotlib版本
print(pl.__version__) #2.2.2
#2.绘制y=x+5和y=2x+5两条曲线
import numpy as np
import matplotlib.pyplot as plt
x=np.linspace(1,10,50)
y1=x+5
y2=2*x+5
plt.plot(x,y1)
plt.plot(x,y2)
plt.title(u"This is y=X 函数",fontproperties="SimHei")
plt.savefig("sen.jpg")
#显示
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

16.figure对象及多图绘制

• 多图的绘制依赖于创建多个figure对象
• ax1=fig.add_subplot(111) #1行1列的第一个图形
• ax2=fig2.add_subplot(111)
• add_subplot(222) #2行2列的第2个图形

#需求：创建子图，并绘制+-x和+-x的拟合直线图（即：给定相同坐标的x）
# 示例代码：
#采用的figure对象
import matplotlib.pyplot as plt
import numpy as np
fig=plt.figure()
ax1 = fig.add_subplot(2, 2, 1) # 2行2列第一个
ax2 = fig.add_subplot(2, 2, 2)
ax3 = fig.add_subplot(2, 2, 3)
ax4 = fig.add_subplot(2, 2, 4)

# 在subplot上作图
x = np.arange(1, 100)
ax1.plot(x, x)
ax2.plot(x, -x)
ax3.plot(-x, x)
ax4.plot(-x, -x)
plt.show()
#采用plt的方式
x=np.arange(1,100)
plt.subplot(221)
plt.plot(x,x)

plt.subplot(222)
plt.plot(x,-x)
plt.show()

# ===================================================
import matplotlib.pyplot as plt
fig=plt.figure(figsize=(10,20))
ax1=fig.add_subplot(212)
ax2=fig.add_subplot(222)
ax3=fig.add_subplot(223)
ax4=fig.add_subplot(224)
ax1.plot([1,2],[2,1])
ax2.plot([1,2],[2,1])
ax3.plot([1,2],[2,1])
ax4.plot([1,2],[2,1])
fig2=plt.figure(figsize=(10,20))
ax2=fig2.add_subplot(111)
ax2.plot([1,2],[2,1])
plt.show()
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

17.figure对象子图创建

• figure对象通过使用add_subplot方法进行图像绘制
• plt.subplot（2，2，1）方法进行图像的绘制—plt.sca(ax1)

import matplotlib.pyplot as plt
fig=plt.figure()
ax1=fig.add_subplot(2,2,1)
ax2=fig.add_subplot(2,2,2)
ax3=fig.add_subplot(2,2,3)
ax4=fig.add_subplot(2,2,4)
ax1.plot([1,2],[2,1])
ax2.plot([1,-2],[-2,1])
ax3.plot([-1,-2],[-2,-1])
ax4.plot([1,-2],[2,-1])
# or
import matplotlib.pyplot as plt
ax1=plt.subplot(221)
ax2=plt.subplot(222)
ax3=plt.subplot(223)
ax4=plt.subplot(224)

ax1.plot([1,2],[2,1])
ax2.plot([1,-2],[-2,1])
ax3.plot([-1,-2],[-2,-1])
ax4.plot([1,-2],[2,-1])
# or
import matplotlib.pyplot as plt
ax1=plt.subplot(221)
plt.sca(ax1)
plt.plot([1,2],[2,1])

ax2=plt.subplot(222)
plt.sca(ax2)
plt.plot([1,-2],[-2,1])


ax3=plt.subplot(223)
plt.sca(ax3)
plt.plot([-1,-2],[-2,-1])

ax4=plt.subplot(224)
plt.sca(ax4)
plt.plot([1,-2],[2,-1])

plt.show()

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

18.Matplotlib各种图形的绘制实战

• 散点图scatter
• 直方图hist
• 箱线图boxplot绘制
• 饼状图pie
• 折线图plot方式

# 需求：使用figure的方式创建子图并做出直方图、散点图、折线图、饼状图、小提琴图
# 指定切分区域的位置
import matplotlib.pyplot as plt
import numpy as np

fig = plt.figure()
ax1 = fig.add_subplot(2, 2, 1)
ax2 = fig.add_subplot(2, 2, 2)
ax3 = fig.add_subplot(2, 2, 3)
ax4 = fig.add_subplot(2, 2, 4)
# 12.3直方图：hist
ax1.hist(np.random.randn(100), bins=10, color='b', alpha=0.3)
# 12.4散点图：scatter
x = np.arange(1,2 * np.pi, 0.1)
y = np.cos(x)
ax2.scatter(x, y)
# 12.4 折线图
#画出-10到10区间的二次函数图
#100改为10就能看出折线图
a=np.linspace(-10,10,100) #平均分为100份
b=a**2
ax3.plot(a,b)
# 12.5饼状图
# 饼状图显示一个数据中各项的大小与各项和的比例
# 饼状图中显示为在整个饼状图中的比例
# labelx = ['A', 'B', 'C', 'D']
# fracs = [15, 30, 45, 10]
# 1.必须设置比例为1:1才能显示为圆形
# plt.axes(aspect=1)
# 2.加每一块所占有具体比例的值autopct
# 3.突出显示explode
# explode = [0, 0.2, 0, 0]  # 块B远离了饼状图中心
# 3.加阴影shadow
# ax4.pie(x=fracs, labels=labelx, autopct='%.1f%%', explode=explode, shadow=True)
x=[0.2,0.4,0.2,0.2]
labels=["A","B","C","D"]
ax3.pie(x, explode=[0,0.4,0,0], labels=labels,shadow=True)
# #箱线图
data = np.random.normal(size=1000, loc=0, scale=1)
# 	#调整异常点的形状sym='o'
# 	#whis参数表示:虚线的长度，默认1.5(比例)，盒子距离上下四分位数的距离
# 	#距离越大虚线越长，设置成0.5和100分别观察
ax4.boxplot(data, sym='o', whis=1.5)
plt.show()
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

参考代码：https://matplotlib.org/gallery/statistics/barchart_demo.html

19.Matplotlib网格Grid实战

• grid网格–设置网格的颜色，设置网格的线条类型，设置网格的线条宽度等

import matplotlib.pyplot as plt

fig = plt.figure()
ax1 = fig.add_subplot(111)
import numpy as np

x = np.linspace(1, 10, 50)
ax1.scatter(x, x ** 2)
ax1.grid(color="r", linestyle="--", linewidth=10)
plt.show()
1
2
3
4
5
6
7
8
9
10

20.Matplotlib图例的用法

• lenged用于指示图片的类型
• plt.legend或ax1.legend方式进行

import matplotlib.pyplot as plt
import numpy as np
x=np.arange(1,11)
plt.plot(x,x**2,label='Normal')
plt.plot(x,x**3,label="Fast")
plt.plot(x,x**4,label="Faster")
#方式1
#ncol=3扁平的效果，排为一列
# plt.legend(loc=2,ncol=3)#1是右上角2是左上角3左下角4右下角0是best , ncol表示分为几列
# 方式2：
plt.legend(['Normal',"Fast","Faster"])
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12

21.Matplotlib颜色、标记、线型说明

• 通常在图片中会指定图的颜色color，标记marker，线条linestyle
• “r–”----red,–虚线 <==> 显式指定：color=red，linestyle="–"
• 面向对象和面向过程区分
• plt.title()-----ax1.set_title（）

ax.plot(x, y, 'r--')
等价于ax.plot(x, y, linestyle='--', color='r')
示例代码：
import matplotlib.pyplot as plt
import numpy as np

fig, axes = plt.subplots(2)
axes[0].plot(np.random.randint(0, 100, 50), 'ro--')
# 等价
axes[1].plot(np.random.randint(0, 100, 50), color='r', linestyle='dashed', marker='o')
常用的颜色、标记、线型：<>
marker
.   point
,	pixel
o 	circle
v	下三角形
^	上三角形
<	左三角形

color
b：blue
g:green
r:red
c:cyan
m:magenta
y:yellow
k:black
w:white

linestyle
- or solid  粗线
-- or dashed  dashed line
-. or dashdot  dash-dotted
: or dotted dotted line
'None'	draw nothing
' ' or '' 什么也不绘画
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

22.Matplotlib综合案例分析

• 面向对象和面向过程
• plt.title & ax1.set_title()
• plt.xlim & ax1.set_xlim()
• plt.legend & ax1.legend()
• 绘制图像的时候一定要加上标题、x和y轴坐标、legend图例

• 案例

方式一 :

import matplotlib.pyplot as plt
import numpy as np
X=np.linspace(-10,10,100)
y1=np.sin(X)
y2=np.sign(X)
y3=np.tanh(X)
fig=plt.figure(figsize=(20,20))
ax1=fig.add_subplot(221)
ax1.plot(X,y1,"r--",linewidth=2)
ax1.set_title("Y=sin(x)")
ax1.set_xlim(2,8)
ax1.grid(color="b")
ax1.legend(loc=0,labels=["Y=sin(x)"])


ax2=fig.add_subplot(222)
ax2.plot(X,y2,"r-.",linewidth=5,label=["Y=sign(x)"])
ax2.set_title("Y=SIGN(X)")
ax2.set_xlim(-5,5)
ax2.set_ylim(-2,2)
ax2.legend(loc=0)



ax3=fig.add_subplot(212)
ax3.plot(X,y3)
ax3.set_xlabel("X")
ax3.set_ylabel("Tahn(X)")
ax3.grid()
ax3.legend(loc=1,labels=["Y=tanh(X)"])

plt.show()
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

方式二 :

import matplotlib.pyplot as plt
import numpy as np
X=np.linspace(-10,10,100)
y1=np.sin(X)
y2=np.sign(X)
y3=np.tanh(X)

plt.figure(figsize=(15,15))

plt.subplot(221)
plt.plot(X,y1,"r--",linewidth=2)
plt.title("Y=sin(x)")
plt.xlim(2,8)
plt.grid(color="b")
plt.legend(loc=0,labels=["Y=sin(x)"])


plt.subplot(222)
plt.plot(X,y2,"r-.",linewidth=5,label=["Y=sign(x)"])
plt.title("Y=SIGN(X)")
plt.xlim(-5,5)
plt.ylim(-2,2)
plt.legend(loc=0)



plt.subplot(212)
plt.plot(X,y3)
plt.xlabel("X")
plt.ylabel("Tahn(X)")
plt.grid()
plt.legend(loc=1,labels=["Y=tanh(X)"])

plt.show()
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

23.Seaborn绘图实战(1)

• seaborn绘图
• import matplotlib.pyplot as plt
• import seaborn as sns
• sns.boxplot绘制图形，hue选项含义参考那个参数
• sns.relplot绘制图形
• sns.catplot绘制图形
• sns.指定不同方法

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import seaborn as sns
sns.set(style="darkgrid")
tips = sns.load_dataset("tips")
#1.处理基础数据
#total_bill和tip关系
# sns.relplot(x="total_bill", y="tip", data=tips);
# sns.relplot(x="total_bill", y="tip", hue="smoker", data=tips);
sns.relplot(x="total_bill", y="tip", hue="smoker",
            col="time", data=tips);
#2.处理时间数据
# df = pd.DataFrame(dict(time=pd.date_range("2017-1-1", periods=500),
#                        value=np.random.randn(500).cumsum()))
# print(df.head())
# g = sns.relplot(x="time", y="value", kind="line", data=df)
# g.fig.autofmt_xdate()
# 3.分类变量
# sns.catplot(x="day", y="total_bill", data=tips);
# sns.catplot(x="day", y="total_bill", hue="sex", kind="swarm", data=tips);
# sns.catplot(x="smoker", y="tip", order=["No", "Yes"], data=tips);
# sns.catplot(x="day", y="total_bill", kind="box", data=tips);
# sns.boxplot(x="day",y="total_bill",hue="smoker",data=tips)
plt.show()
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

24.Seaborn绘图实战(2)

• 通过seaborn获取绘图信息
• 解决泰坦尼克号的获救问题—女性较男性获救概率更高，头等仓位比其他仓位获救概率较高
• sns.catplot
• 只要指定x和y的数据就可以进行图形展示

import matplotlib.pyplot as plt
import seaborn as sns
sns.set(style="darkgrid")

titanic = sns.load_dataset("titanic")
# sns.catplot(x="sex", y="survived", hue="class", kind="bar", data=titanic);
# sns.catplot(x="deck", kind="count", palette="ch:.25", data=titanic);
sns.catplot(y="deck", hue="class", kind="count",
            palette="pastel", edgecolor=".6",
            data=titanic);
plt.show()
1
2
3
4
5
6
7
8
9
10
11

25.Scipy了解

• Scipy是基于numpy之上可以实现科学计算、工程计算、 图形图像处理、fft(傅里叶变换)等形式
• 数学上定积分、求解多项式、导数等问题均可求解
• 重点详述了Scipy中的sparse矩阵中的svds矩阵分解
• 利用svds和eigs等进行矩阵分解，从而实现矩阵分解方式的推荐系统

from scipy import signal,misc
import numpy as np
import matplotlib.pyplot as plt
image=misc.ascent() #二维图像，公寓图像
w=np.zeros((50,50))
w[0][0]=1.0 #修改参数调整滤波器
w[49][25]=1.0 #可以根据需要调整
image_new=signal.fftconvolve(image,w) #使用FFT算法进行卷积

plt.figure()
plt.imshow(image_new) #显示滤波后的图像
plt.gray()
plt.title("Filteres image!")
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14

26.Sklearn了解

• 包含机器学习各种算法，目前集成了
  • 分类
  • 回归
  • 聚类
  • 降维
  • 特征工程
• 以线性回归的例子为例展开
  • 求解机器学习模型问题—机器学习参数的求解问题
  • 使用fit方法训练模型
  • 使用predict方法进行预测

from sklearn import linear_model
reg = linear_model.LinearRegression()
x = [[0, 0], [1, 1], [2, 2]]
y = [0, 1, 2]
reg.fit (x, y) #Fit linear model.
# LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None,
#                  normalize=False)
print(reg.coef_) #[0.5 0.5] w1x1+w2x2+w0  w1=0.5,w2=0.5
print(reg.intercept_) #w0=0
import numpy as np
print(np.allclose(0,reg.intercept_))
# array([0.5, 0.5])
print(reg.predict([[0,0],[1,1]]))
1
2
3
4
5
6
7
8
9
10
11
12
13

Scipy的API官网 : https://docs.scipy.org

27.Scipy之SVD补充

利用svds和eigs等进行矩阵分解，从而实现矩阵分解方式的推荐系统

from scipy.sparse import csc_matrix
import numpy as np
# from scipy.sparse.linalg import svds, eigs
from scipy.sparse import linalg
A = csc_matrix([[1, 0, 0], [5, 0, 2], [0, -1, 0], [0, 0, 3]], dtype=float)
u, s, vt = linalg.svds(A, k=2)
print(u)
# [[-1.73323831e-01  1.56782328e-01]
#  [-2.27856346e-01  9.54078802e-01]
#  [-7.09160926e-19  2.32081766e-19]
#  [ 9.58144214e-01  2.55250744e-01]]
print(s)
# [2.75193379 5.6059665 ]
print(vt)
# [[-4.76975707e-01  1.95156391e-18  8.78916478e-01]
# [ 8.78916478e-01 -1.30104261e-18  4.76975707e-01]]
# array([ 2.75193379,  5.6059665 ])
print(np.sqrt(linalg.eigs(A.dot(A.T), k=2)[0]).real)
# 特征向量
# 根号下特征值就是奇异值
# array([ 5.6059665 ,  2.75193379])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

基于协同过滤系统的Python实现

import numpy as np
import pandas as pd
header = ['user_id', 'item_id', 'rating', 'timestamp']
df = pd.read_csv('ml-100k/u.data', sep='\t', names=header)
n_users = df.user_id.unique().shape[0]
n_items = df.item_id.unique().shape[0]
Print('Number of users = ' + str(n_users) + ' | Number of movies = ' + str(n_items)) 
# Number of users = 943 | Number of movies = 1682
from sklearn import cross_validation as cv
train_data, test_data = cv.train_test_split(df, test_size=0.25)

#Create two user-item matrices, one for training and another for testing
train_data_matrix = np.zeros((n_users, n_items))
for line in train_data.itertuples():
    train_data_matrix[line[1]-1, line[2]-1] = line[3]  
    test_data_matrix = np.zeros((n_users, n_items))
for line in test_data.itertuples():
    test_data_matrix[line[1]-1, line[2]-1] = line[3]
from sklearn.metrics.pairwise import pairwise_distances
    user_similarity = pairwise_distances(train_data_matrix, metric='cosine')
    item_similarity = pairwise_distances(train_data_matrix.T, metric='cosine')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

28.总结