3.机器学习—数据科学包3.1numpy基础

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

numpy、pandas简介

1. 科学运算中，最重要的两个模块，numpy和pandas。任何关于数据分析的，都少不了用他们。
2. 比如说用tensorflow和maching leaning，都会用到数据分析，要用数据分析，使用numpy和pandas会让数据分析计算得非常快，比python自带的list、dict要快很多。
3. 因为numpy和pandas是用C语言写的，pandas又是基于numpy，是numpy的升级版本，且用到了矩阵运算。
   举例说明：矩阵运算
   
   上面的矩阵，如果单独运算每一个数，可能会很耗费cpu，英文是competitional expensive，耗费计算机能力。所以在单位时间内用矩阵计算一大堆数据比单个单个用dict/list快很多，而且这个矩阵计算是放在C语言(底层语言)计算的，所以会快很多倍。
   看神经网络应用numpy/pandas的例子，

安装numpy、pandas

numpy安装
几种方法

1. 上官网可以查看各种用法
   搜索numpy install/numpy download，
   进入numpy官方网站
   
   To install NumPy, we strongly recommend using a scientific Python distribution。
   官方推荐用scientific Python distribution，即下载Anaconda，其中就集成好了。

其他用法参照See Installing the SciPy Stack for details。
Scipy，科学计算，数值计算库，函数
stack，堆栈，栈

2. 方法1
   Distributions，即Anaconda集成的
3. 方法2
   pip安装
   windows用户用pip安装可能会遇到多种问题，因为电脑上可能缺少支持numpy/pandas的文件，会要求去下载这些文件。

pandas安装
可搜索pandas python download进入pandas官网查看

可进入pandas官网或者查看其他文档

linux/mac用户安装numpy/pandas会遇到更少麻烦。

numpy基本属性

引入模块

numpy是一个外部模块，所以需要import，将numpy简写为np。
使用numpy的功能，np.dot

import numpy as np #将numpy简写为np
np.dot #使用np的功能

array：矩阵/数组

1. 什么是矩阵
   矩阵可能是一维数组或二维数组

[[1,2,3],
 [2,3,4]] #3列2行的矩阵
 # 这仅是一个列表，想要将其转换为一个numpy可以识别的矩阵。先给这个列表命名。
 array = [[1,2,3],
          [2,3,4]] #命名为数组
 # 然后再用到np.array()
  array = np.array ([[1,2,3],
                    [2,3,4]]) #这就是将一个列表转换为矩阵的方法。就是将后面一堆数字定义为数组
# numpy会对你输入的这些数组，有一些特定的属性

2. numpy矩阵的固有属性：
   对你输入的这些数组，numpy将其转化为矩阵，numpy矩阵的固有属性：这个array的长宽，size，形状，维度(几维数组)。
   

array = np.array ([[1,2,3],
                    [2,3,4]])
print('number of dim:',array.ndim)  #或print('number of dimension:'array.ndim) 矩阵的维度,一维/二维
print('shape:',array.shape) #shape是矩阵的行列数
print('size:',array.size) # size是总共有多少元素在里面

创建array：矩阵/数组

import numpy as np
a= np.array([2,23,4]) #()中输入想创建的array是什么样的array，一般用list形式。
print(a) #看起来跟list没啥差别，但是其中没有逗号来分隔，这是array的特殊之处

#定义array的数值类型，type，是float还是int。可以在创建时就定义type。
#array的type是dtype，数值类型，np有自己的定义格式
a = np.array([2,23,4],dtype=np.int) #int默认是64位的。32位的要写上int32.float同理。还有16位的
# 位数越小占用空间越小，想要更精确位数就越大，占用内存/空间越大,想要精确就保留64位的，想要更多空间/内存存储，可以忽略精度，就用16位的。
# numpy中有更多数据形式，可以自己搜索一下。google/百度
print(a.dtype)

#上面的是一维array，要定义二维array，比如要定义一个矩阵。跟python中定义list类似，在list外面再加一层list。
a = np.array([[2,23,4],
              [2,3,4]]) #对齐后，会发现这是一个矩阵。2行3列矩阵，
print(a)
a = np.zeros((3,4)) #生成一个全部为0的矩阵。()中输入要定义为几行几列。(3,4)3行4列。
a = np.ones((3,4),dtype=np.int16) #生成一个全部为1的矩阵
a = np.empty ((3,4)) #empty是什么都没有，实际上是非常接近0的数字，

# 生成有序序列，和python中range类似，有起始值和终止值,步长。
a = np.arange(10,20,2 )

# 生成数列，定义shape
a = np.arange(12).reshape((3,4)) #0-11,12位数列，定义长宽，3行4列

#生成线段数列
a = np.linespace(1,10,20) #从1到10，20段的数列
a = np.linespace(1,10,6) #更改shape.1到10，6段，6个数字分布在2行3列矩阵中。

numpy的基础运算

计算一维数组

import numpy as np
a = np.array([10,20,30,40]) #生成一维数组
b = np.arange(4) #生成一维数组
# 以上是两种生成数组的方式
print(a,b) #同时打印2个矩阵
c = a - b #矩阵的减法，数组内逐个相减，加减乘除一样
print(c)
c = b**2 #数组的平方

# 用数学函数，比如三角函数，要调用np中的函数
c = 10*np.sin(a) #先将a数组中的每个元素求sin值，再整体乘以10

#判断数组中的元素和某一个元素的大小，结果为布尔型的数组
print(b<3)
print(b==3)

c = 10*np.sin(a)

print(b<3)

计算二维数组

a = np.array([[1,1],
              [0,1]])
b = np.arange(4).reshape((2,2))
print(a,b) #d多维数组放到一起显示容易看不清
print(a)
print(b)
print(b==3)

# 数组的乘法：np中的乘法分两种，1，逐个相乘，2，数学中的矩阵乘法
c = a * b #逐个相乘
c_dot = np.dot(a,b) #数学中的矩阵乘法
c_dot_2 = a.dot(b) #a本身就是一个np的数组，因而可以直接在自身上调用np方法。意思是a和b以矩阵形式相乘

print(a,b)

print(a)
print(b)

上面为c = a * b #逐个相乘,
下面为c_dot = np.dot(a,b) #数学中的矩阵乘法

c_dot = np.dot(a,b)
c_dot_2 = a.dot(b)

其他计算

import numpy as np
a = np.random.random((2,4)) #np中的随机生成数字，给定创建array的shape.此处为2行4列的shape
np.sum(a) #一个array中所有元素的和
np.min(a) #一个array中所有元素的最小值
np,max(a) #一个array中所有元素的最大值
print(np.sum(a,axis=1)) # 仅计算某一行/列,axis是轴、维度，axis=1就是在列数中求和，axis=0是在行数中求和。这里有2行，就会返回2个元素
print(np.min(a,axis=0)) #这里有4列，就会返回4个元素
print(np.max(a,axis=1)) #这里有2行，就会返回2个元素

a = np.random.random((2,4))

np.sum(a)
np.min(a)
np,max(a)

print(np.sum(a,axis=1))
print(np.min(a,axis=0))
print(np.max(a,axis=1))

其他运算

import numpy as np
A = np.arange(2,14).reshape((3,4))
# np中行和列的序列很重要，可以指定行/列的运算，

#求索引
np.argmin(A) #array中最小值的索引，argument索引
np.argmax(A)

# 求平均值
np.mean(A) #整个矩阵的平均值
A.mean() #与上同
np.average(A) #与上同
A.average() #不识别 

#求中位数
np.median((A)) 

#累加
np.cumsum(A) #累加的每一步都会显示，不是仅显示最后一个和
#累差，每两个数之间的差
np.diff(A) #所有相邻两个数的差

np.nonzero(A) #找出array中所有非0的数在哪里

#排序
np.sort(A) #按照一行排序

#矩阵相乘中用到一个概念，transpose，矩阵的反向
transpose，调换，移项，颠倒顺序，进行变换，转置
np.transpose(A) #行和列交换
print(A.T)
# 矩阵乘法
print((A.T).dot(A)) #矩阵A的反向和矩阵A的乘法

#clip功能，切片。clip裁剪，削减
np.clip(A,5,9) #A中所有小于5的数都等于5，所有大于9的数都等于9，中间的数保留原型

np.cumsum(A)

np.diff(A) #所有相邻两个数的差

np.nonzero(A) #找出array中所有非0的数在哪里

np.transpose(A) #行和列交换
print(A.T)

np.clip(A,5,9) #A中所有小于5的数都等于5，所有大于9的数都等于9

np的所有计算功能都可以指定行计算还是列计算 axis=1，行计算，axis=0，列计算

numpy的索引读取

在array中，根据位置找到值，根据位置处理array中的运算

import numpy as np

#numpy array的位置索引
#一维
A = np.arange(3,15)
print(A)
print(A[3]) #与python中list一样，numpy.array也可以位置索引。意思为A的第三个值
#二维
A = np.arange(3,15).reshape((3,4))
print(A)
print(A[2]) #行数索引，从0开始，第二行
print(A[1][1]) #行和列一起索引，第1行第1列
print(A[2,1]) #与上同，第二行第一列
# 用冒号代替所有数
print(A[2,:]) #第2行的所有数
print(A[:,1]) #第1列的所有数
print(A[1,1:2]) #第1行的第1位到第2位的值，不包括第2位，所以只有一个值

# for循环
for row in A:
    print(row)c#打印出所有行
# 打印所有列，没有这个手段，但是可以间接实现
for column in A.T: #A.T是A的转置矩阵，行变为列
    print(column)
# 迭代出矩阵中的每一个元素
prinr(A.flatten) #将A转变为只有一行的数组，由数组转化为list。显示结果为list
print(A.flat) #不显示，只显示对象属性，为numpy.flatiter对象，object，是一个迭代器
for item in A.flat: 
    print(item)
  

print(A.flat)

prinr(A.flatten)
for item in A.flat:
print(item)

numpy array合并

按行合并，按列合并

# np.vstack,np.hstack,可对多个array合并
A = np.array([1,1,1])
B = np.array([2,2,2])
# 上下合并，按照列
C = np.vstack((A,B)) #vertical stack纵向堆叠
print(A.shape,C.shapr)
# 左右合并，按照行
D = np.hstack((A,B)) #horizontal stack水平堆叠
print(A.shape,D.shape)

#仅有一行的array是数列，不是矩阵，不支持transpose。将横向数列转置为纵向数列，用np.newaxis,在array的数列上添加一个轴/维度，使其变为矩阵
print(A.T.shape) #不可用
print(A[np.newaxis,:]) #在A数组的行上添加一个维度，
print(A[np.newaxis,:].shape) #shape为1行3列
print(A[:,np.newaxis].shape) #在列上添加维度，原来的数列中的列变为行，变为3行1列array

#将A和B都由数列变为数组。数列中的3个数变为数组中的3行1列
A = np.array([1,1,1])[:,np.newaxis]
B = np.array([2,2,2])[:,np.newaxis]
D = np.hstack((A,B))
print(D)
print(A.shape,D.shape)

#多个array合并，concatenate连结，结锁。np.concatanate可定义在哪个维度合并
C = np.concatenate(（A,B,B,A),axis=0) #axis=0,纵向合并
C = np.concatenate(（A,B,B,A),axis=1) #横向合并

C = np.vstack((A,B))

print(A.shape,D.shape)

print(A[np.newaxis,:].shape)

print(A[:,np.newaxis].shape)

print(D)
print(A.shape,D.shape)

nump分隔array

import numpy as np
A = np.arange(12).reshape((3,4))
print(A)
print(np.split(A,2,axis=1)) #横向分隔为2个array
print(np.split(A,3,axis=0)) #横向分隔为3个array
print(np.split(A,3,axis=1)) #报错：只能进行相等分割，不能将4列分为3块。

#实现不等量分割，np.array_split
print(np.array_split(A,3,axis=1)) #横向不等量分割

#np.vsplit(),np.hsplit(),
print(np.vsplit(A,3)) #横向分割为3快
print(np.hsplit(A,2)) #纵向分割为2快

print(np.split(A,2,axis=1)) #横向分隔为2个array

print(np.split(A,3,axis=1)) #报错：只能进行相等分割，不能将4列分为3块。

print(np.array_split(A,3,axis=1)) #横向不等量分割

print(np.vsplit(A,3)) #横向分割为3快
print(np.hsplit(A,2)) #纵向分割为2快

nump array的赋值

将array赋值给另外一个变量

a = np.arange(4)
a
b = a
c = a
d = b
a[0] = 0.3 #这里默认是整数，赋值给0.3就变为0
a 
a[0] = 11
a
# 注意a赋值给b/c之后，a改变，b和c也会改变，这是和python不同的地方

#在a赋值给b之后，实现a改变，b不改变。建立a的一个副本，copy，让b指向a的副本。这样a改变，b不会随之改变
b = a.copy() #deep copy