python数据分析【2】numpy

1 创建数组

1.1 np.array () 一维&二维数组

基于list或者tuple

import numpy as np
# 一维数组
arr1 = np.array([1,2,3,4])
arr2 = np.array((1,2,3,4))

# 二维数组 (2*3)
arr3 = np.array([[1,2,4], [3,4,5]])

print(arr1)
print(arr2)
print(arr3)

[1 2 3 4]
[1 2 3 4]
[[1 2 4]
 [3 4 5]]

1.2 np.arrange() 一维&二维数组

# 一维数组
arr4 = np.arange(5)

# 二维数组
arr5 = np.array([np.arange(2), np.arange(3)])

#指定数值类型
a1 = np.arange(5, dtype=float) #浮点数
a2 = np.array([1.22,3.45,6.779], dtype="int8") #整数
a3 = np.arange(5, dtype='D') #复数
#转换数值类型，注意：复数不能转换为int或者float
#a1.int8
#a2.float


print(arr4)
print(arr5)
print("----——————————-分隔符————————————-----")
print(a1)
print(a2)
print(a3)

[0 1 2 3 4]
[array([0, 1]) array([0, 1, 2])]
----——————————-分隔符————————————-----
[0. 1. 2. 3. 4.]
[1 3 6]
[0.+0.j 1.+0.j 2.+0.j 3.+0.j 4.+0.j]

x = np.arange(1,11)

[ 1  2  3  4  5  6  7  8  9 10]

1.3 np.arrange() 多维数组

arr = np.arange(24).reshape(2,3,4)
print(arr)

[[[ 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 数组的各个属性

ndim属性，数组维度的数量。

shape属性，数组对象的尺度对于矩阵，即n行m列,shape是一个元组（tuple）。

size属性，用来保存元素的数量，相当于shape中nXm的值。

itemsize属性，返回数组中各个元素所占用的字节数大小。

nbytes属性，如果想知道整个数组所需的字节数量，可以使用nbytes属性。其值等于数组的size属性值乘以itemsize属性值。

T属性，数组转置。

flat属性，返回一个numpy.flatiter对象，即可迭代的对象。

2.1 ndim shape size itemsize nbytes

arr5 = np.array([np.arange(3), np.arange(3)])
print(arr5)
print(arr5.ndim)
print(arr5.shape)
print(arr5.size)
print(arr5.itemsize)
print(arr5.nbytes)

[[0 1 2]
 [0 1 2]]
2
(2, 3)
6
4
24

arr = np.arange(24).reshape(2,3,4)
print(arr)
print(arr.ndim)
print(arr.shape)
print(arr.size)
print(arr.itemsize)
print(arr.nbytes)

[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
3
(2, 3, 4)
24
4
96

2.2 T

#转置
b = np.arange(24).reshape(4,6)
print(b)
print(b.T)

[[ 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  6 12 18]
 [ 1  7 13 19]
 [ 2  8 14 20]
 [ 3  9 15 21]
 [ 4 10 16 22]
 [ 5 11 17 23]]

#也可以用transpose()来实现转置
print(b.transpose())

[[ 0  6 12 18]
 [ 1  7 13 19]
 [ 2  8 14 20]
 [ 3  9 15 21]
 [ 4 10 16 22]
 [ 5 11 17 23]]

2.3 flat

e = np.arange(6).reshape(2,3)
f = e.flat
print(e)
print(f)

#迭代
for item in f:
    print(item)

print("————分隔符————")    
#通过位置进行索引
print(f[2])
#print(f[1,4])，会出错，要多加一层中括号  
print(f[[1,4]])
#可以直接对flat进行赋值
e.flat[[1,4]] = 9
print(e)

[[0 1 2]
 [3 4 5]]
<numpy.flatiter object at 0x0000021437B687F0>
0
1
2
3
4
5
————分隔符————
2
[1 4]
[[0 9 2]
 [3 9 5]]

2.4 复数数组的属性

real属性，复数的实部
imag属性，复数的虚部

c = np.arange(5,dtype='D')

print(c)
print(c.real)
print(c.imag)

[0.+0.j 1.+0.j 2.+0.j 3.+0.j 4.+0.j]
[0. 1. 2. 3. 4.]
[0. 0. 0. 0. 0.]

3 ndarray数组的切片和索引

d =  np.arange(5)
print(d)
print(d[1])
print(d[1:5])
print(d[:5:2]) #每隔两个取一个

[0 1 2 3 4]
1
[1 2 3 4]
[0 2 4]

d1 = np.arange(24).reshape(4,6)

print(d1)
print(d1[0:3,0:2]) #行数取[0:3]共3行，列数取[0:2]，共两列
print(d1[0:3,0:2].shape)
 #逗号前面的冒号表示所有行都取值，2表示每一个行取第三个数值
print(d1[:,2],d1[:,2].shape)
print(d1[2,:],d1[2,:].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]]
[[ 0  1]
 [ 6  7]
 [12 13]]
(3, 2)
[ 2  8 14 20] (4,)
[12 13 14 15 16 17] (6,)
 

d2 = np.arange(24).reshape(2,3,4)
print(d2)
print("----——————分隔符-----")
print(d2[0:1,0:2])

print(d2[0:1,0:2,0: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]]]
    ----——————分隔符-----
    [[[0 1 2 3]
      [4 5 6 7]]]
    ----——————分隔符-----
    [[[0 1]
      [4 5]]]

4 数组的方法

reshape()、resize()
ravel()、flatten()

4.1 reshape()、resize()

函数resize（）的作用跟reshape（）类似，但是会改变所作用的数组，相当于有inplace=True的效果
reshape：有返回值，所谓有返回值，即不对原始多维数组进行修改；
resize：无返回值，所谓有返回值，即会对原始多维数组进行修改；

d3 = np.arange(12).reshape(3,4)

print(d3)
print(d3.reshape(2,6))
print(d3.resize(6,2))

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
None

4.2 ravel()、flatten()

将多维数组转换成一维数组

flatten()：返回拷贝，不会修改原始值，较常用
ravel(): 返回视图，会影响原始值

d4 = np.arange(12).reshape(2,3,2)

print(d4)
print(d4.ravel())

[[[ 0  1]
  [ 2  3]
  [ 4  5]]

 [[ 6  7]
  [ 8  9]
  [10 11]]]
[ 0  1  2  3  4  5  6  7  8  9 10 11]

d4.flatten()[0]=999
print(d4)

[[[ 0  1]
  [ 2  3]
  [ 4  5]]

 [[ 6  7]
  [ 8  9]
  [10 11]]]

d4.ravel()[0]=999
print(d4)

[[[999   1]
  [  2   3]
  [  4   5]]

 [[  6   7]
  [  8   9]
  [ 10  11]]]

d4.reshape(3,4)

array([[999,   1,   2,   3],
       [  4,   5,   6,   7],
       [  8,   9,  10,  11]])

5 数组的计算

5.1 与常数相加、相乘

#数组*常数
d5 = np.arange(12).reshape(2,6)
c = d5 * 2

print(d5)
print("--------分隔符-------")
print(c)

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
--------分隔符-------
[[ 0  2  4  6  8 10]
 [12 14 16 18 20 22]]

 c = d5 + 2
print(c)

[[ 2  3  4  5  6  7]
 [ 8  9 10 11 12 13]]

5.2 数组的叠加

5.2.1 hstack()、column_stack() 和 row_stack()、vstack()

# 叠加 hstack()，水平上的元素进行相加
d6 = (np.arange(12)*2).reshape(2,6)
  ##注意是双括号

print(d6)
print("--------分隔符-------")
print(np.hstack((d5,d6)))

[[ 0  2  4  6  8 10]
 [12 14 16 18 20 22]]
--------分隔符-------
[[ 0  1  2  3  4  5  0  2  4  6  8 10]
 [ 6  7  8  9 10 11 12 14 16 18 20 22]]

print(np.vstack((d5,d5)))

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]

# 叠加 vstack()，垂直上的元素进行相加

5.2.2 concatenate()

通过设置axis的值来设置叠加方向

axis=1时，沿水平方向叠加
axis=0时，沿垂直方向叠加

d7 = np.concatenate((d5,d5),axis = 0)
print(d7)

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]

5.2.3 dstack() 深度叠加 (增加维度）

print(d5)

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]

print(d6)

[[ 0  2  4  6  8 10]
 [12 14 16 18 20 22]]

d8 = np.dstack((d5,d6))
print(d8)

[[[ 0  0]
  [ 1  2]
  [ 2  4]
  [ 3  6]
  [ 4  8]
  [ 5 10]]

 [[ 6 12]
  [ 7 14]
  [ 8 16]
  [ 9 18]
  [10 20]
  [11 22]]]

6 数组的拆分

6.1 hsplit()、vsplit()、split()

# hsplit()沿横轴拆分
print(d5)  # 二维数组

print("--------分隔符-------")
d9 = np.hsplit(d5,2)         
print(d9)  # 变成一维数组list

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
--------分隔符-------
[array([[0, 1, 2],
       [6, 7, 8]]), array([[ 3,  4,  5],
       [ 9, 10, 11]])]



---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-112-acb36bbb98f9> in <module>
      5 d9 = np.hsplit(d5,2)
      6 print(d9)
----> 7 print(d9.shape)


AttributeError: 'list' object has no attribute 'shape'

# vsplit()沿纵轴拆分
d10 = np.vsplit(d5,2)
print(d10)

[array([[0, 1, 2, 3, 4, 5]]), array([[ 6,  7,  8,  9, 10, 11]])]

# split() axis=1 时沿横轴拆分，axis=0 时沿纵轴拆分
d9 = np.split(d5,2,axis=1)
print(d9)

[array([[0, 1, 2],
       [6, 7, 8]]), array([[ 3,  4,  5],
       [ 9, 10, 11]])]

d10 = np.split(d5,2,axis=0)
print(d10)

[array([[0, 1, 2, 3, 4, 5]]), array([[ 6,  7,  8,  9, 10, 11]])]

list1 = [[1,2,3],[4,5,6],[7,8,9]]
print(list1)
arr = np.array(list1)
print(arr)
print(arr.shape)

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
[[1 2 3]
 [4 5 6]
 [7 8 9]]
(3, 3)

6.2 dsplit() 深度拆分（只能对三维及以上的数组拆分）

# dsplit()深度拆分  
print(d8)   
print("--------分隔符-------")
d11 = np.dsplit(d8,2)
print(d11)   #（2,6,2）
print(d8.shape)
# print(d11.shape) 会出错，因为d11被拆分出来后变成了list

[[[ 0  0]
  [ 1  2]
  [ 2  4]
  [ 3  6]
  [ 4  8]
  [ 5 10]]

 [[ 6 12]
  [ 7 14]
  [ 8 16]
  [ 9 18]
  [10 20]
  [11 22]]]
--------分隔符-------
[array([[[ 0],
        [ 1],
        [ 2],
        [ 3],
        [ 4],
        [ 5]],

       [[ 6],
        [ 7],
        [ 8],
        [ 9],
        [10],
        [11]]]), array([[[ 0],
        [ 2],
        [ 4],
        [ 6],
        [ 8],
        [10]],

       [[12],
        [14],
        [16],
        [18],
        [20],
        [22]]])]
(2, 6, 2)

7 数组的类型转换

7.1 array转换成list：tolist()

print(d5)

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]

d12 = d5.tolist()
print(d12)

[[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10, 11]]

7.1 转换数据类型

d5.astype(float)  # 不改变原来数组
print(d5) 
print(d5.astype(float))

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 11.]]

8 统计计算

8.1 sum()、mean()、max()、min()

print(d5)
print(d5.sum())  #求和
print(d5.mean()) #均值
print(d5.max())  #最大值
print(d5.min())  #最小值

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
66
5.5
11
0

8.2 ptp()、cumsum()、cumprod()

np.ptp()，数组沿指定轴返回最大值减去最小值，即（max-min）
np.cumsum()，返回累加值
np.cumprod()，返回累乘积值

print(d5)
print(d5.ptp())
print(d5.cumsum())
print(d5.cumprod())

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
11
[ 0  1  3  6 10 15 21 28 36 45 55 66]
[0 0 0 0 0 0 0 0 0 0 0 0]

print(d5.ptp(axis=1))
print(d5.ptp(axis=0))

[5 5]
[6 6 6 6 6 6]

print(d5.cumsum(axis=1))
print(d5.cumsum(axis=0))

[[ 0  1  3  6 10 15]
 [ 6 13 21 30 40 51]]
[[ 0  1  2  3  4  5]
 [ 6  8 10 12 14 16]]

print(d5.cumprod(axis=1))
print(d5.cumprod(axis=0))

[[     0      0      0      0      0      0]
 [     6     42    336   3024  30240 332640]]
[[ 0  1  2  3  4  5]
 [ 0  7 16 27 40 55]]

8.3 std()、var()

np.std()，返回标准偏差（standard deviation）
np.var()，返回方差（variance）

print(d5)
print(d5.std())
print(d5.var())

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]
3.452052529534663
11.916666666666666

print(d5.std(axis=1))
print(d5.var(axis=1))

[1.70782513 1.70782513]
[2.91666667 2.91666667]

print(d5.std(axis=0))
print(d5.var(axis=0))

[3. 3. 3. 3. 3. 3.]
[9. 9. 9. 9. 9. 9.]

9 数组的判断

d2 = np.arange(1,5)
print(d2 == 2)

[False  True False False]

根据判断值，查找索引

d2 = np.arange(1,5)
judge = (d2 == 2)

print(judge)
print(d2[judge]) ##注意是中括号

如果判断有多个True呢？

d2 = np.array([1,1,2,2,4,5]) ##注意这里是array
judge = (d2 == 2)

print(judge)
print(d2[judge])

多条件判断
and：&
or：|

d2 = np.array([1,1,2,2,4,5])
judge = (d2 > 2) & (d2 < 5)

print(judge)
print(d2[judge])

[False False False False  True False]
[4]