NumPy入门指南(一) | Day1
同学们好！
今天我们开始数据分析第二期的课程啦~~~
今明两天我们主要学习NumPy，NumPy是用Python做数据分析时不可或缺的一个库，想知道它怎么使用吗？快往下看吧！（ps:课程内容较多，大家坚持住哦！）
NumPy介绍
NumPy(Numerical Python)是Python中一个非常重要的第三方库，用于快速处理任意维度的数组。NumPy支持常见的数组和矩阵操作。对于同样的数值计算任务，使用Numpy比直接使用Python内置的方法要快速，方便。
NumPy中的数组的存储效率和输入输出性能均远远优于Python中等价的基本数据结构，且其能够提升的性能是与数组中的元素成比例的。
NumPy的大部分代码用C语言编写，其底层算法在设计时就有着优异的性能，这使得NumPy比纯Python代码高效得多。
下面我们来看一个案例：通过记录时间差，对比Python列表数据结构和Numpy数组ndarray计算数组求和来对比两者的效率
import random
import time
import numpy as np
# 创建列表a来存放（100000000）个随机数
a = []
for i in range(100000000):
a.append(random.random()) # append是将()中的元素添加到列表的末尾
# 记录Python对列表a求和的时间差
t1 = time.time() # time.time() 获得当前时间
sum1=sum(a) #
t2=time.time()
# 记录使用Numpy中的array数据结构，对数组a求和的时间差
b=np.array(a)
t3=time.time()
sum2=np.sum(b)
t4=time.time()
print(t2-t1, t4-t3)# 运行结果：
3.891148090362549 0.19675397872924805
“”“
运行后需要等待几秒钟可以看到计算结果；
Python列表中元素求和的运行时间将近4s，
而Numpy中的array数据结构只需要0.2s。
”“”NumPy中的数组ndarray
ndarray(N-dimensional array object)是NumPy中的多维数组，它是一系列同类型数据的集合，而在Python的列表数据结构中，里面的元素可以是不同类型的数据；此外，ndarray中元素在数组[ ]中显示时，元素间没有逗号。
创建一维数组
一般不能直接创建ndarray，通过读取列表来创建数组，可以采用三种方法：
- 转换list到array
- 使用python的函数range生成序列
- 使用numpy自带的函数arange,用法与range相同
import numpy as np
list_a = [1,2,3,4]
onedArray = np.array(list_a) # 将列表转换为NumPy数组
# 查看数据类型
print(type(onedArray)) # type函数可以查看数据类型
print(onedArray)
"""
运行结果：
<class 'numpy.ndarray'>
[1 2 3 4]
数据类型是numpy中的ndarray,[]中元素间没有逗号
"""
# 创建数组的其他形式
## 1.直接传入列表的方式
t1 = np.array([1,2,3])
print(t1)
print(type(t1))
'''
运行结果：
[1 2 3]
<class 'numpy.ndarray'>
'''
## 2. 传入range生成序列
t2 = np.array(range(10))
print(t2)
print(type(t2))
'''
运行结果：
[0 1 2 3 4 5 6 7 8 9]
<class 'numpy.ndarray'>
'''
## 3. 使用numpy自带的np.arange()生成数组
t3 = np.arange(0,10,2)
print(t3)
print(type(t3))
'''
运行结果：
[0 2 4 6 8]
<class 'numpy.ndarray'>
'''创建二维数组
取出数组中的元素，方法与取出列表中的元素相同：指定元素的下标序号，第一个元素的下标是0。取出二维数组中的元素的方法，与一维数组相同，先指定第几个一维数组，再从取得的一维元素中指定元素的下标。
import numpy as np
list2 = [[1,2],[3,4],[5,6]]
twodArray = np.array(list2)
print(twodArray)
'''
运行结果：
[[1 2]
[3 4]
[5 6]]
二维数组对应的类似excel中的行和列，可以和sql交互
'''
# 二维列表可以看做列表里面放列表
# 取出二维列表list2中的第一个元素
print(list2[0])
"""
运行结果：
[1,2]
"""
# 如何取出二维列表list2中第一个一维列表中的第一个元素？
print(list2[0][0])
"""
运行结果：
'1'
"""常用属性
通过查询ndim属性可以得知数组的维度，shape属性得知形状；如果是二维数组，shape用几行几列来描述；size属性表示数组中有几个元素。
import numpy as np
list2 = [[1,2],[3,4],[5,6]]
twodArray = np.array(list2)
# ndim: 获取数组的维度
print(twodArray.ndim)
'''2'''
# shape:形状(行，列)
print(twodArray.shape)
'''(3, 2)'''
# size数组中有多少个元素
print(twodArray.size)
'''6'''调整数组的形状
调整数组的形状就是改变数组的行数和列数，类似于我们在大学数学中学习的矩阵。通过建立数组可以保存excel和数据库中的数据。那么如何调整行和列，也就是修改形状呢？
这里提供两个方法，一是给shape的属性赋值，二是使用reshape()函数。
import numpy as np
twodArray = np.array([[1,2,3],[4,5,6]])
# 修改数组形状：
# 方法1：给属性shape赋值
one = twodArray
one.shape=(3,2)
print(one)
'''
[[1 2]
[3 4]
[5 6]]
'''
# 方法2：函数reshape()，返回一个新的数组
two = twodArray.reshape(2,3)
print(two)
'''
[[1 2 3]
[4 5 6]]
'''
# 将多维数组变成一维数组
three = twodArray.reshape((6,),order='F')
# order参数中,'C'是默认,以行展开，'F'(Fortran风格)以列展开；
print(three)
'''
[1 3 5 2 4 6]
'''
four = twodArray.reshape((6,),order='C')
print(four)
'''
[1 2 3 4 5 6]
'''数组形状拓展：
我们继续使用reshape()函数，将一个一维数组，转化为二维和三维数组。
二维数组可以存放x和y轴(行和列)两个维度的信息，三维数组还可以增加一个z轴。
import numpy as np
t = np.arange(24)
print(t)
print(t.shape) # 一行24列
'''
[ 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,)
'''
# 转换成二维
t1 = t.reshape((4,6)) #四行六列
print(t1)
print(t1.shape)
'''
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
(4, 6)
'''
# 转换成三维
t2 = t.reshape((2,3,4)) # （2，3，4）三维数组里有两组元素，每个元素有三行，四列
print(t2)
print(t2.shape)
'''
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
(2, 3, 4)
'''将数组转成列表:
函数tolist()可以将ndarray数组转换成Python列表
import numpy as np
a = np.array([9, 12, 88, 14, 25])
list_a = a.tolist()
print(list_a)
print(type(list_a))
'''
[9, 12, 88, 14, 25]
<class 'list'>
'''NumPy的数据类型
NumPy数组由于提升了计算的性能，数组中的元素直接存储数据，默认是int，但是计算时如果数据是浮点型，一定要说明数据类型是浮点型。而python中的列表存储元素的方式是在列表中存放一个指针，指针指向数据，因而计算速度也降低了。
Numpy最主要的功能就是科学计算，计算时，numpy的数组支持的数据类型有：
举例来说，int16是整数16位，可以存放的数字大小从-32768 至 32767，占 2个字节，一个字节是8位，两个字节16位，不同的精度对内存空间的占用大小不同。
通过指定或者修改nupmy数组中的dtype属性来设置数组的数据类型。
import numpy as np
f = np.array([1,2,3,4,5], dtype = np.int16)
# 输出数组中每个元素的字节单位长度
print(f.itemsize)
# 获取数据类型
print(f.dtype)
# 调整数据类型
f1 = f.astype(np.int32)
print(f1.dtype)
#----- 随机生成小数 -----
# 使用Python语法，保留2位
import random # random生成0-1内的小数，如果随机数需要扩大十分位，后面乘以100
print(round(random.random(),2)) #round：约分保留2位小数
## 使用numpy语法
f2 = np.array([random.random() for i in range(10)])
# [random.random() for i in range(10)]是一个列表表达式，for i in range(10)循环在这里是多次循环的功能，循环十次，产生一个含有10个随机数的列表
print(np.round(f2,2))
# 运行结果：
'''
2
int16
int32
0.3
[0.64 0.52 0.4 0.22 0.3 0.08 0.8 0.62 0.83 0.51]
''' 数组的计算
Numpy的主要功能是对数值型的数据进行计算,学习如何对数组进行计算是后续数据分析的基础。
Pandas可以对其他类型的数据进行操作，Numpy和Pandas之间的关系类似matplotlib和seaborn的关系。
数组和数的计算
numpy的广播机制存在运算过程中，加减乘除的值被广播到所有的元素上面。举例来说，对数组进行加减乘除，相当于对数组中的每一个元素进行加减乘除。
import numpy as np
t1 = np.arange(24).reshape((6,4))
print(t1)
print(t1+2)
print(t1*2)
print(t1/2)
# 运行结果：
'''
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]
[[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]
[14 15 16 17]
[18 19 20 21]
[22 23 24 25]]
[[ 0 2 4 6]
[ 8 10 12 14]
[16 18 20 22]
[24 26 28 30]
[32 34 36 38]
[40 42 44 46]]
[[ 0. 0.5 1. 1.5]
[ 2. 2.5 3. 3.5]
[ 4. 4.5 5. 5.5]
[ 6. 6.5 7. 7.5]
[ 8. 8.5 9. 9.5]
[10. 10.5 11. 11.5]]
'''数组和数组之间的操作
数组和数组存在形状的差异，不同形状的数组如何计算呢？
同种形状的数组：对应位置进行计算操作
import numpy as np
t1 = np.arange(24).reshape((6,4))
t2 = np.arange(100,124).reshape((6,4))
print(t1)
print(t2)
print(t1+t2)
print(t1*t2)
# 运行结果：
'''
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]
[[100 101 102 103]
[104 105 106 107]
[108 109 110 111]
[112 113 114 115]
[116 117 118 119]
[120 121 122 123]]
[[100 102 104 106]
[108 110 112 114]
[116 118 120 122]
[124 126 128 130]
[132 134 136 138]
[140 142 144 146]]
[[ 0 101 204 309]
[ 416 525 636 749]
[ 864 981 1100 1221]
[1344 1469 1596 1725]
[1856 1989 2124 2261]
[2400 2541 2684 2829]]
'''不种形状的多维数组:不能计算
import numpy as np
t1 = np.arange(24).reshape((4,6))
t2 = np.arange(18).reshape((3,6))
print(t1)
print(t2)
print(t1-t2)
# 运行结果：
'''
ValueError: operands could not be broadcast together with shapes (4,6) (3,6)
'''行数或者列数与多维数组相同的一维数组可以进行计算:
1.行形状相同(会与每一行数组的对应位相操作)
2.列形状相同(会与每一个相同维度的数组的对应位相操作)
import numpy as np
# 行形状相同 （列数相同）
t1 = np.arange(24).reshape((4,6))
t2 = np.arange(0,6)
print(t1)
print(t2)
print(t1-t2)
# 运行结果：
'''
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
[0 1 2 3 4 5]
[[ 0 0 0 0 0 0]
[ 6 6 6 6 6 6]
[12 12 12 12 12 12]
[18 18 18 18 18 18]]
'''
# 列形状相同 （行数相同）
t3 = np.arange(24).reshape((4,6))
t4 = np.arange(4).reshape((4,1))
print(t3)
print(t4)
print(t3-t4)
# 运行结果
'''
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
[[0]
[1]
[2]
[3]]
[[ 0 1 2 3 4 5]
[ 5 6 7 8 9 10]
[10 11 12 13 14 15]
[15 16 17 18 19 20]]
'''数组中的轴
1.什么是轴: 在numpy中可以理解为方向，使用0，1，2数字表示，对于一个一维数组，只有一个0轴，对于2维数组(shape(2，2))有0轴和1轴，对于3维数组(shape(2，2，3))有0，1，2轴。
2.为什么要学习轴(axis): 有了轴的概念后，我们计算会更加方便，比如计算一个2维数组的平均值，必须指定是计算哪个轴方向上数值的平均值。
当axis=0时，为跨行计算，方向可以记忆为右，相当于x轴正数的方向，但计算的是x轴方向上的列值；例如：sum求和, 那么三列分别相加，跨行计算，结果是[5 7 9]。
同理，axis=1时为跨列计算，方向为下，y轴的负数方向，计算的是y轴行的值；sum求和时，两行内的三列分别相加，结果是[6 15]。
三维数组中，0轴 axis = 0 时，计算时，从同位置的元素的方向计算，相当于”穿透“。例如求和时，是把二维数组中相同位置的元素在0轴方向上相加，那么计算出的结果第一个位置的元素的和等于 1 + 7 + 14 = 22。同理，1轴和2轴的计算就是二维数组中0轴和1轴的计算方法。
import numpy as np
a = np.array([[1,2,3],[4,5,6]]) # 2行3列的数组
print(np.sum(a,axis=0)) # 0轴方向上的求和，[5 7 9]
print(np.sum(a,axis=1)) # 1轴方向上的求和，[ 6 15]
print(np.sum(a)) # 计算所有的值的和 21
#三维的数据
a = np.arange(27).reshape((3,3,3))
print(a)
'''
[[[ 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]]]
'''
b = np.sum(a, axis=0)
print(b)
'''
[[27 30 33]
[36 39 42]
[45 48 51]]
'''
c = np.sum(a, axis=1)
print(c)
'''
[[ 9 12 15]
[36 39 42]
[63 66 69]]
'''
c = np.sum(a, axis=2)
print(c)
'''
[[ 3 12 21]
[30 39 48]
[57 66 75]]
'''