一、numpy

（一）矩阵

1.创建矩阵

（1）mat()

格式1：字符串

A = np.mat('1 0 0 0;0 1 0 0;-1 2 1 0;1 1 0 1')
print(A)

格式2：列表

B = np.mat([[1,0,0,0],[0,1,0,0],[-1,2,1,0],[1,1,0,1]])
print(B)

（2）matrix()

同mat()

# 格式1：字符串
C = np.matrix('1 0 0 0;0 1 0 0;-1 2 1 0;1 1 0 1')
print(C)
# 格式2：列表
D = np.matrix([[1,0,0,0],[0,1,0,0],[-1,2,1,0],[1,1,0,1]])
print(D)

（3）bmat()

通过分块矩阵创建big矩阵

Big_Mat = np.bmat('A B;C D')
print(Big_Mat)
Big_Mat = np.bmat([[A,B],[C,D]])
print(Big_Mat)

2.矩阵运算

（1）矩阵与数相乘–数乘

A = np.mat([[1,1],[1,1]])
print(A*3)

（2）矩阵加减法

B = np.mat([[1,2],[3,4]])
print(A+B)

（3）矩阵相乘

print(A*B)

（4）矩阵对应位置元素相乘

C = np.multiply(A,B)
print(C)

（5）矩阵的常用数据

转置–T
```
print(C.T)
```
共轭转置矩阵–H
```
print(C.H)
```
逆矩阵–I
```
print(C.I)
```

返回自身数据的一个视图–A

print(type(C))    # <class 'numpy.matrixlib.defmatrix.matrix'>
print(type(C.A))    # <class 'numpy.ndarray'>
print(C.A)

（二）使用numpy进行数据分析–文件读取

import numpy as np

x = np.array([[1,1,1],[2,2,2],[3,3,3],[4,4,4]])
y = np.array([1,2,3,4]).reshape((4,1))

1.保存

（1）save()

保存的是二进制文件，文件的扩展名：.npy。

np.save('x',x)

（2）savetxt()

保存的是文本文件。

np.savetxt('x_txt',x)

二进制文件会比文本文件的处理速度快，效率高。

（3）savez()

可以将多个数据保存成一个压缩文件。

a = np.array([[1,2,3],[4,5,6]])
b = np.arange(0,1,0.1)
np.savez('a_b',a,b)

2.读取

注意：存储时可以省略扩展名，但读取时不能省略。

（1）load()

result = np.load('x.npy')
print(type(result),'\n',result)

（2）loadtxt()

读取文本文件（txt/csv）

result = np.loadtxt('x_txt',dtype=np.int32)
print(result)

（3）genfromtxt()

保存结构化数据。

# 1.创建结构
df = np.dtype([('name',np.str_,128),('nums',np.int32),('local',np.str_,16)])
# 2.读取结构化数据
jobs = np.genfromtxt('tecent_jobs.txt',dtype=df,delimiter=',')
print(jobs['name'])
print(jobs['nums'],type(jobs['nums']))
print(jobs['local'])

（三）排序问题

1.直接排序

sort()

直接修改原始数据。

sort()是最常用的排序方法，arr.sort()。

sort()也可以指定一个axis参数，使得sort()可以沿着指定轴对数据集进行排序。

axis=1为沿行轴排序；axis=0为沿纵轴排序。

arr = np.array([[4,3,2],[2,1,4]])
arr.sort(axis=1)
print(arr)
arr.sort(axis=0)
print(arr)

2.间接排序

间接排序不更改原始数据的物理结构。

（1）argsort()

返回值为一个数组，存放的是排序后元素的下标。

arr = np.array([2,1,0,5,3])
new_arr = arr.argsort()

（2）lexsort()

按照()中的最后一个数组进行排序，相同再比较其他数组的对应位置，返回结果也是索引。

a = np.array([3,2,6,4,5])
b = np.array([50,40,30,20,10])
c = np.array([400,300,600,100,200])
result = np.lexsort((a,b,c))
print(result)

（四）去重和重复

1.去重

arr = np.array([1,2,1,2,3,3])
print(np.unique(arr))

2.重复

（1）tile()

将整体看作重复对象。

result = np.tile(arr,3)
print(result)    # [1 2 3 4 1 2 3 4 1 2 3 4]

还可以指定行列重复次数。

result = np.tile(arr,(3,1))
print(result)
# [[1 2 3 4]
#  [1 2 3 4]
#  [1 2 3 4]]
result = np.tile(arr,(3,2))
print(result)
# [[1 2 3 4 1 2 3 4]
#  [1 2 3 4 1 2 3 4]
#  [1 2 3 4 1 2 3 4]]

（2）repeat()

将元素看作重复对象。

result = np.repeat(arr,3)
print(result)    # [1 1 1 2 2 2 3 3 3 4 4 4]

可通过axis参数，指定轴。

axis=1按列进行重复，axis=0按行进行重复。

arr = np.array([[1,2],[3,4]])
result = np.repeat(arr,2)
print(result)    # [1 1 2 2 3 3 4 4]
result = np.repeat(arr,2,axis=0)
print(result)
# [[1 2]
#  [1 2]
#  [3 4]
#  [3 4]]
result = np.repeat(arr,2,axis=1)
print(result)
# [[1 1 2 2]
#  [3 3 4 4]]

区别：tile函数是对数组整体进行重复操作，而repeat是对数组中的每个元素进行重复操作。

练习

生成一个3*3的数组，数据元素为10以内的整数（随机生成）
将数组按行进行重复，重复次数为2

arr = np.random.randint(0,10,size=(3,3))
result = np.repeat(arr,2,axis=0)
print('arr:\n',arr)
print('result:\n',result)

（五）统计函数

import numpy as np

arr = np.arange(20).reshape((4,5))

# 写法1
# np.函数名(数组名)
# 写法2
# 数组名.函数名()

# 求和
print(np.sum(arr))
print(arr.sum())

# 平均值
print(arr.mean())

# 标准差/方差
print(arr.std(),arr.var())

# 累加和
print(arr.cumsum())

# 累乘积
print(arr.cumprod())

练习

读取iris数据集中的花萼长度数据（已保存为csv格式）
并对其进行排序、去重
求和、累计和、均值、标准差、方差、最小值、最大值

import numpy as np
# 读取文件
iris = np.loadtxt('iris_sepal_length.csv')
print('花萼长度表为：\n',iris)

# 直接排序
iris.sort()
print('排序后：\n',iris)

# 去重
unique_iris = np.unique(iris)
print('去重：\n',unique_iris)

# 和
print('和：\n',np.sum(unique_iris))
# 累加和
print('累加和：\n',np.cumsum(unique_iris))
# 均值
print('均值：\n',np.mean(unique_iris))
# 标准差
print('标准差：\n',np.std(unique_iris))
# 方差
print('方差：\n',np.var(unique_iris))
# 最小值
print('最小值：\n',np.min(unique_iris))
# 最大值
print('最大值：\n',np.max(unique_iris))

二、KNN算法–最近邻算法

思想：一个样本与数据集中的k个样本最相似，如果这k个样本中的大多数属于一个类别，则该样本也属于这个类别。

计算相似度–欧式距离

例：根据样本集，判断x电影的类型

import math

# 1.使用python字典构造数据集
movie_data = {
    "宝贝当家": [45, 2, 9, "喜剧片"],
    "美人鱼": [21, 17, 5, "喜剧片"],
    "澳门风云3": [54, 9, 11, "喜剧片"],
    "功夫熊猫3": [39, 0, 31, "喜剧片"],
    "谍影重重": [5, 2, 57, "动作片"],
    "叶问3": [3, 2, 65, "动作片"],
    "伦敦陷落": [2, 3, 55, "动作片"],
    "我的特工爷爷": [6, 4, 21, "动作片"],
    "奔爱": [7, 46, 4, "爱情片"],
    "夜孔雀": [9, 39, 8, "爱情片"],
    "代理情人": [9, 38, 2, "爱情片"],
    "新步步惊心": [8, 34, 17, "爱情片"]
}

# 2.计算距离
x = [23,3,17]
KNN = []
for k,v in movie_data.items():
    d = math.sqrt((v[0]-x[0])**2+(v[1]-x[1])**2+(v[2]-x[2])**2)
    KNN.append([k,round(d,2)])    # round(d,2)，将d保留两位小数，四舍五入
# print(KNN)

# 3.取k个距离最短的样本
KNN.sort(key=lambda data:data[1])

KNN = KNN[:5]

choice = {}
for one in KNN:
    movie_name = one[0]
    type = movie_data[movie_name][3]
    choice[type] = choice.get(type,0) + 1
choice = sorted(choice.items(),key=lambda c:c[1],reverse=True)    # items()中是元组
# print(choice)    # 存放元组的列表
print('x的类型为：',choice[0][0])

迭代和循环

迭代不是循环！！

迭代就是一个一个的取，它不同于循环，不可以倒着取。

数据分析（三）--numpy，KNN算法