numpy

NumPy的数组类被称作ndarray

ndarry的创建：

创建一维数组：类型为ndarray

array是一个类似ones的函数

import numpy as np

a=np.array([1,2,3])
print(a)
print(type(a))

 

结果：

[1 2 3]
<class 'numpy.ndarray'>

创建二维数组：

a=np.array([[1,2,3],[4,5,6]])
print(a)

 

结果：

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

创建三维数组：

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

 

结果：

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

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

创建0数组：(3,2)代表二维数组，第一维有三个数组，第二维有二个

a=np.zeros((3,2))
print(a)

 

结果：

[[ 0. 0.]
[ 0. 0.]
[ 0. 0.]]

创建全1数组：

a=np.zeros((3,2,2))
print(a)

结果：

[[[ 0. 0.]
[ 0. 0.]]

[[ 0. 0.]
[ 0. 0.]]

[[ 0. 0.]
[ 0. 0.]]]

 

empty：调用和上一个一样大小的矩阵，上一个3*3是全1下面的也是全1，上面的变全0下面的也是全0

arr_one=np.ones((3,3))
print('arr_one:')
print(arr_one)
arr=np.empty((3,3),dtype='i1')
print('arr:')
print(arr)
arr_zeros=np.zeros((3,3))
print('arr_zeros:')
print(arr_zeros)
arr3=np.empty((3,3),dtype='i1')
print(arr3)
print(arr3)

 

arr_one:
[[ 1. 1. 1.]
[ 1. 1. 1.]
[ 1. 1. 1.]]
arr:
[[1 1 1]
[1 1 1]
[1 1 1]]
arr_zeros:
[[ 0. 0. 0.]
[ 0. 0. 0.]
[ 0. 0. 0.]]
[[0 0 0]
[0 0 0]
[0 0 0]]
[[0 0 0]
[0 0 0]
[0 0 0]]

 

arange函数: 类似python的range函数，通过指定开始值、终值和步长来创建一个一维数组，注意：最终创建的数组不包含终值

a=np.arange(20)
b=np.arange(1,20)
c=np.arange(10,20,2)
d=np.arange(20,15,-1)
print(a)
print(b)
print(c)
print(d)

 

结果：

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

linspace函数：通过指定开始值、终值和元素个数来创建一个一维数组，数组的数据元素符合等差数列，

endpoint为True表示包含最后的值，否则不包含，如果包含的话步长为终值-初始值再除以个数-1，不包含就不用减1

retstep为True显示步长

arr=np.linspace(0,10,5,endpoint=False,retstep=True)
print(arr)
arr2=np.linspace(0,10,6)
print(arr2)
arr3=np.linspace(0,10,5,endpoint=True)
print(arr3)

(array([ 0., 2., 4., 6., 8.]), 2.0)
[ 0. 2. 4. 6. 8. 10.]
[ 0. 2.5 5. 7.5 10. ]

 

logspace函数：和linspace函数类似，不过创建的是等比数列数组，0和2表示10的0次方和10的2次方 可以指定底数为2

步长是终值除以初值再开个数的次方

可以用来控制学习率，一开始很大后来很小

a=np.logspace(0,2,5)
b=np.logspace(0,2,5,base=2)
print(a)
print(b)

 

使用随机数填充数组：即使用numpy.random中的random()函数来创建0-1之间的随机元素，数组包含的元素数量由参数决定

random.rand()和它有类似的效果 这个和上面的用的少主要用来加噪音

random.randn()生成正太分布的值，用来生成初始权重的值 这个和下面的用的比较多

random.randint():生成指定范围整数形式

a=np.random.random((3,2,3))
print(a)

b=np.random.randint(0,9,size=([3,2,3]))
print(b)

 [[[ 0.16457832 0.62392568 0.12147039]

[ 0.93102204 0.94546256 0.89936897]]

[[ 0.76421283 0.76901106 0.85803104]
[ 0.78047088 0.12490645 0.20241544]]

[[ 0.81234778 0.1706378 0.46777206]
[ 0.46362101 0.65915849 0.81233809]]]

 

[[[1 7 2]
[0 3 2]]

[[4 8 3]
[2 2 1]]

[[4 5 8]
[3 5 6]]]

ndarray对象属性：

shape： 数组的维度, 例如一个2排3列的矩阵，它的shape属性将是(2,3),这个元组的长度显然是秩，即维度或者ndim属性

size ：数组元素的总个数，等于shape属性中元组元素的乘积

dtype： 一个用来描述数组中元素类型的对象

itemsize： 数组中每个元素的字节大小

ndim：维数

a=np.random.random((3,2,3))
print(a)
print(a.shape)
print(a.size)
print(a.dtype)
print(a.ndim)

结果：

[[[ 0.69687113 0.64635635 0.33509638]
[ 0.89577043 0.52402303 0.14022035]]

[[ 0.75843167 0.97081013 0.27377149]
[ 0.55884246 0.51996251 0.13923623]]

[[ 0.54949654 0.09005034 0.42206612]
[ 0.94917494 0.38606105 0.79835506]]]
(3, 2, 3)
18
float64
3

 

Numpy基本数据类型：int_默认整型，int8-i1(1个字节2的0次方，一个字节是8位，2的8次方是-127-128)  int16-i2...

uint8-u1(u就是无符号，简单来说就是正整数) 

float16-f2  float32-f4(1个符号位+8位指数+23位小数)

既有数字又有数字定义object

String_-S 字节  一个字符一个字节

Unicode_-U 字符串 每个字符占用字节数由平台决定

修改数据类型：

修改其实是新的数组原来的数组没有变

a=np.array([1,2,3,4])
print(a.dtype)
b=a.astype(float)
print(a.dtype)
print(b.dtype)

int32
int32
float64

 

ndarray修改形状

直接使用reshape函数创建一个改变尺寸的新数组，原数组的shape保持不变，但是新数组和原数组共享一个内存空间，也就是修改任何一个数组中的值都会对另外一个产生影响，另外要求新数组的元素个数和原数组一致

a=np.arange(0,20,2)
b=a.reshape(5,2)
print(a)
print(b)
b[0][1]=100
print(a)
print(b)

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

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

当指定某一个轴为-1的时候，表示将根据数组元素的数量自动计算该轴的长度值

reshape修改复制之后的形状，a.shape修改原数组的形状

a=np.arange(0,20,2)
b=a.reshape(5,-1)
print(a)
print('-'*20)
print(b)
print('-'*20)
a.shape=(2,-1)
print(a)

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

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

 

Numpy基本操作

ndarray-数组与标量、数组之间的运算：数组不用循环即可对每个元素执行批量的算术运算操作，这个过程叫做矢量化，即用数组表达式代替循环的做法

1.矩阵与数之间的运算

a=np.arange(1,6)
print(a)
print(a+2)
print(a-2)
print(a*2)
print(a/2)
print(1/a)
print(a**2)
print(2**a)

[1 2 3 4 5]

[3 4 5 6 7]
[-1 0 1 2 3]
[ 2 4 6 8 10]
[ 0.5 1. 1.5 2. 2.5]
[ 1. 0.5 0.33333333 0.25 0.2 ]
[ 1 4 9 16 25]
[ 2 4 8 16 32]

本质上是前面的np.arange(20)，只要里面的数字相同即可,结果和维度多的那个一样

a=np.arange(20).reshape(1,4,5)
print('a=')
print(a)
print('-'*20)
b=np.arange(20).reshape(4,5)
print('b=')
print(b)
print('-'*20)
print('a+b=')
print(a+b)

a=
[[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]]
--------------------
b=
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
--------------------
a+b=
[[[ 0 2 4 6 8]
[10 12 14 16 18]
[20 22 24 26 28]
[30 32 34 36 38]]]

2.矩阵与矩阵之间的运算

arr1=np.array([[1,2,3],[4,5,6]])
arr2=np.array([[4.6,3.2,2.1],[5.2,4.3,3.4]])
print('arr1+arr2=')
print(arr1+arr2)
print('arr1-arr2=')
print(arr1-arr2)
print('arr1*arr2=')
print(arr1*arr2)
print('arr1/arr2=')
print(arr1/arr2)

 arr1+arr2=

[[ 5.6 5.2 5.1]
[ 9.2 9.3 9.4]]
arr1-arr2=
[[-3.6 -1.2 0.9]
[-1.2 0.7 2.6]]
arr1*arr2=
[[ 4.6 6.4 6.3]
[ 20.8 21.5 20.4]]
arr1/arr2=
[[ 0.2173913 0.625 1.42857143]
[ 0.76923077 1.1627907 1.76470588]]

不同形状的数组进行运算，通过广播能力,4和4要对应上才可以乘

a=np.array([1,2,3,4])#(4,)
b=np.array([[10,20,30,40],[1,2,3,4]])#(2,4)
print(a*b)

 

[[ 10 40 90 160]
[ 1 4 9 16]]

 

3.数组的矩阵积：dot和inner在二维上是一样的，三维上有区别

arr1=np.array([[1,2],[4,5]])
arr2=np.array([[4.6,3.2],[5.2,4.3]])
print(arr1.dot(arr2))
arr3=np.dot(arr1,arr2)
print(arr3)

 [[ 15. 11.8]

[ 44.4 34.3]]
[[ 15. 11.8]
[ 44.4 34.3]]

 

矩阵索引

arr=np.array([
    [
        [2,3,4,5],[1,3,4,9]
    ],
    [
        [0,3,4,8],[2,4,9,4]
    ],
    [
        [1,4,5,8],[2,5,6,8]
    ],
    [
        [2,3,6,8],[3,4,8,9]
    ]
])
print(arr[3])
print('-'*20)
print(arr[3,1])
print('-'*20)
print(arr[3][1][2])
print('-'*20)
print(arr[3,1,2])

 

结果：

[[2 3 6 8]
[3 4 8 9]]
--------------------
[3 4 8 9]
--------------------
8
--------------------
8

在各维度上单独切片，如果某维度都保留，则直接使用：，不指定起始值和终止值

注意：Numpy中通过切片得到的新数组，只是原来数组的一个试图，因此对新数组进行操作也会影响原数组，不能使用arr[:][:][1:3]如果这样，第一个[]就默认把数组取完了

arr=np.array([
    [
        [2,3,4,5],[1,3,4,9]
    ],
    [
        [0,3,4,8],[2,4,9,4]
    ],
    [
        [1,4,5,8],[2,5,6,8]
    ],
    [
        [2,3,6,8],[3,4,8,9]
    ]
])
print(arr[3][1][1:3])
print('-'*20)
print(arr[3,1,1:3])

 

结果：

[4 8]
--------------------
[4 8]

利用布尔类型的数组进行数据索引，最终返回的结果是对应索引数组中数据为True位置的值

arr=np.random.random((4,4))
arr2=arr<0.5
print(arr2)
arr3=arr[arr2]
print(arr3,arr3.shape)

 [[False False False False]

[ True False True False]
[False True False False]
[ True False True True]]
[ 0.2886168 0.49285157 0.09925616 0.00371036 0.0282944 0.20428113] (6,)

Numpy中不能使用and、or和not，相应的替代为| & ~

names=np.array(['Gerry','Tom','John'])
scores=np.array([
    [98,87,86,95],
    [58,56,54,51],
    [78,85,85,77]
])
classes=np.array(['语文','数学','英语','科学'])
print('Gerry score is:',scores[names=='Gerry'].reshape((-1)))
print('Gerry math score is:',scores[names=='Gerry'].reshape((-1))[classes=='数学'])
print('Gerry and Tom scores are: ',scores[(names=='Gerry')|(names=='Tom')])
print('not Gerry and Tom scores are: ',scores[(names!='Gerry')&(names!='Tom')])

 Gerry score is: [98 87 86 95]

Gerry math score is: [87]
Gerry and Tom scores are: [[98 87 86 95]
[58 56 54 51]]
not Gerry and Tom scores are: [[78 85 85 77]]

 

花式索引：花式索引(Fancy indexing)指的是利用整数数组进行索引的方式

arr=np.arange(32).reshape(8,4)
print(arr)
print('获取第0,3,5行数据')
print(arr[[0,3,5]])
print('获取第（0,0）、（3,3）、（5,2）这三个位置的数据')
print(arr[[0,3,5],[0,3,2]])
print('获取第0、3、5行的第0、2、3列的数据')
print(arr[np.ix_([0,3,5],[0,2,3])])

 [[ 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 27]
[28 29 30 31]]
获取第0,3,5行数据
[[ 0 1 2 3]
[12 13 14 15]
[20 21 22 23]]
获取第（0,0）、（3,3）、（5,2）这三个位置的数据
[ 0 15 22]
获取第0、3、5行的第0、2、3列的数据
[[ 0 2 3]
[12 14 15]
[20 22 23]]

 

矩阵的转置

arr=np.arange(32).reshape(8,4)
print(arr,arr.shape)
arr1=arr.transpose()
print('转置后的数据')
print(arr1,arr1.shape)
print('第二种方法：')
print(arr.T,arr.T.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]
[24 25 26 27]
[28 29 30 31]] (8, 4)
转置后的数据
[[ 0 4 8 12 16 20 24 28]
[ 1 5 9 13 17 21 25 29]
[ 2 6 10 14 18 22 26 30]
[ 3 7 11 15 19 23 27 31]] (4, 8)
第二种方法：
[[ 0 4 8 12 16 20 24 28]
[ 1 5 9 13 17 21 25 29]
[ 2 6 10 14 18 22 26 30]
[ 3 7 11 15 19 23 27 31]] (4, 8)

多维度转置,(3,4,2)对应的位置分别是0,1,2，transpose(1,0,2)对应的就是4,3,2可以自己计算，比如一个位置是(2,3,1) 转置过后的位置就是（3,2,1）

a=np.arange(24).reshape(3,4,2)
print(a)
print(a.shape)
a=a.transpose(1,0,2)
print(a)
print(a.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]]]
(3, 4, 2)
[[[ 0 1]
[ 8 9]
[16 17]]

[[ 2 3]
[10 11]
[18 19]]

[[ 4 5]
[12 13]
[20 21]]

[[ 6 7]
[14 15]
[22 23]]]
(4, 3, 2)

 Ndarray常用函数

abs/fabs:去绝对值，fabs快一点

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.abs(arr))
print(np.fabs(arr))

 [ 5.3 6.2 5. 0. 4.2 5. 3. 2. 1. ]

[ 5.3 6.2 5. 0. 4.2 5. 3. 2. 1. ]

sqrt:平方更，要求每个元素大于等于0

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.sqrt(np.fabs(arr)))

 [ 2.30217289 2.48997992 2.23606798 0. 2.04939015 2.23606798

1.73205081 1.41421356 1. ]

square:计算每个元素的评分，相当于arr**2

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.square(arr))

  [ 28.09  38.44  25.     0.    17.64  25.     9.     4.     1.  ]

 exp：计算每个元素的指数e的x次方

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.exp(arr))

 [ 4.99159391e-03 2.02943064e-03 6.73794700e-03 1.00000000e+00

6.66863310e+01 1.48413159e+02 2.00855369e+01 7.38905610e+00
2.71828183e+00]

log、log10、log2、log1p：分别计算自然对数、底数为10的log、底数为2的log以及log(1+x)；要求arr中的每个元素必须为正数

numpy做不了以2和10其他以外的底数的计算

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
arr=np.fabs(arr+1)
arr=np.fabs(arr)
print(np.log(arr))
print(np.log10(arr))
print(np.log2(arr))
print(np.log1p(arr))

 [ 1.45861502 1.64865863 1.38629436 0. 1.64865863 1.79175947

1.38629436 1.09861229 0.69314718]
[ 0.63346846 0.71600334 0.60205999 0. 0.71600334 0.77815125
0.60205999 0.47712125 0.30103 ]
[ 2.10433666 2.37851162 2. 0. 2.37851162 2.5849625 2.
1.5849625 1. ]
[ 1.66770682 1.82454929 1.60943791 0.69314718 1.82454929 1.94591015
1.60943791 1.38629436 1.09861229]

sign：计算每个元素的符号1表示正 0:0 -1表示负号

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.sign(arr))

[-1. -1. -1.  0.  1.  1.  1.  1.  1.]

ceil：计算大于等于该值得最小整数

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.ceil(arr))

 [-5. -6. -5.  0.  5.  5.  3.  2.  1.]

floor：与ceil对应，去小于或等于该值得最大整数

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.floor(arr))

 [-6. -7. -5.  0.  4.  5.  3.  2.  1.]

rint：四舍五入最接近的整数

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.rint(arr))

 [-5. -6. -5.  0.  4.  5.  3.  2.  1.]

modf：将数组中的整数和小数分两个数组返回

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.modf(arr))

 (array([-0.3, -0.2, -0. ,  0. ,  0.2,  0. ,  0. ,  0. ,  0. ]), array([-5., -6., -5.,  0.,  4.,  5.,  3.,  2.,  1.]))

isnan：不是数字的bool值isnan是is not a number缩写

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.isnan(arr))

 [False False False False False False False False False]

isfinte:判断是否是无穷的

isinf：判断是否是有限的

arr=np.array([np.pi,3])
print(np.isfinite(arr))
print(np.isinf(arr))

 [ True True]

[False False]

sin、cos、tan、sinh、cosh、tanharccos、arccosh、arcsin、arcsinh、arctan、arctanh:：双曲正弦sinhx=[e^x-e^(-x)]/2,双曲余弦coshx=[e^x+e^(-x)]/2，双曲正切tanh=(e^(-x)-e^x)/(e^(-x)+e^x)

arr=np.array([np.pi/2,np.pi/3,np.pi/4])
print(np.sin(arr))
print(np.cos(arr))
print(np.tan(arr))
print(np.sinh(arr))
print(np.cosh(arr))
print(np.tanh(arr))

 [ 1. 0.8660254 0.70710678]

[ 6.12323400e-17 5.00000000e-01 7.07106781e-01]
[ 1.63312394e+16 1.73205081e+00 1.00000000e+00]
[ 2.3012989 1.24936705 0.86867096]
[ 2.50917848 1.60028686 1.32460909]
[ 0.91715234 0.78071444 0.6557942 ]

mod:元素级取余
greater:arr2>arr1
greater_equal:arr2>=arr1
less:arr2<arr1
less_equal:arr2<=arr1
equal:arr2==arr1
not_equal:arr2!=arr1

arr1=np.array([1,2,8,1])
arr2=np.array([4,5,6,1])
print('np.mod(arr2,arr1)=',np.mod(arr2,arr1))
print('greater:arr2>arr1:',np.greater(arr2,arr1))
print('greater:arr2>=arr1:',np.greater_equal(arr2,arr1))
print('greater:arr2<arr1:',np.less(arr2,arr1))
print('greater:arr2<=arr1:',np.less_equal(arr2,arr1))
print('greater:arr2==arr1:',np.equal(arr2,arr1))
print('greater:arr2!=arr1:',np.not_equal(arr2,arr1))

 np.mod(arr2,arr1)= [0 1 6 0]

greater:arr2>arr1: [ True True False False]
greater:arr2>=arr1: [ True True False True]
greater:arr2<arr1: [False False True False]
greater:arr2<=arr1: [False False True True]
greater:arr2==arr1: [False False False True]
greater:arr2!=arr1: [ True True True False]

logical_and、logical_or、logical_xor：执行元素级别的布尔逻辑运算，相当于中缀运算符&、|、^

arr1=np.array([1,2,8,1])
arr2=np.array([4,5,6,0])
print(np.logical_or(arr1,arr2))
print(np.logical_and(arr1,arr2))
print(np.logical_xor(arr1,arr2))

 [ True True True True]

[ True True True False]
[False False False True]

power：相当于arr1**arr2

arr1=np.array([1,2,8,1])
arr2=np.array([4,5,6,0])
print(np.power(arr1,arr2))

 [     1     32 262144      1]

Numpy聚合函数

axis=0按列计算
axis=1按行计算
mean:去平均值  默认求全局的
min:最小值
max：最大值
sum：求和
std：标准差 np.sqrt(np.power(arr-arr.mean(),2)).sum()/arr.size

arr=np.array([
    [1,3,5,9],
    [2,4,6,8],
    [-5,-6,-8,-2]
])
print('arr.mean（axis=0）',arr.mean(axis=0))
print('arr.min（axis=1）',arr.min(axis=1))
print('arr.max',arr.max())
print('arr.sum（axis=1）',arr.sum(axis=1))
print('arr.std（axis=0）',arr.std(axis=0))

 arr.mean（axis=0） [-0.66666667 0.33333333 1. 5. ]

arr.min（axis=1） [ 1 2 -8]
arr.max 9
arr.sum（axis=1） [ 18 20 -21]
arr.std（axis=0） [ 3.09120617 4.49691252 6.37704216 4.96655481]

 np.where函数

xarr=np.array([-1.1,-1.2,-1.3,-1.4,-1.5])
yarr=np.array([-2.1,-2.2,-2.3,-2.4,-2.5])
condiion=xarr<yarr
result1=[x if c else y for (x,y,c) in zip(xarr,yarr,condiion)]
print(result1,type(result1))
result2=np.where(condiion,xarr,yarr)
print(result2,type(result2))

 [-2.1000000000000001, -2.2000000000000002, -2.2999999999999998, -2.3999999999999999, -2.5] <class 'list'>

[-2.1 -2.2 -2.3 -2.4 -2.5] <class 'numpy.ndarray'>

将数组中的所有异常数字替换为0，比如将NaN替换为0

arr=np.array([
    [1,2,np.NaN,4],
    [4,5,6,np.NaN],
    [7,8,9,np.NaN],
    [np.inf,np.e,np.pi,4]
])
condition=np.isnan(arr)|np.isinf(arr)
print('原始数据：')
print(arr)
print('修改后的数据：')
print(np.where(condition,0,arr))

 原始数据：

[[ 1. 2. nan 4. ]
[ 4. 5. 6. nan]
[ 7. 8. 9. nan]
[ inf 2.71828183 3.14159265 4. ]]
修改后的数据：
[[ 1. 2. 0. 4. ]
[ 4. 5. 6. 0. ]
[ 7. 8. 9. 0. ]
[ 0. 2.71828183 3.14159265 4. ]]

unique：去重操作

arr=np.array(['图书','数码','图书','小吃','小吃'])
print('原始数据：')
for i in arr:
    print(i,end=' ')
print()
print('修改后的数据：')
arr1=np.unique(arr)
for i in arr1:
    print(i,end=' ')

 原始数据：

图书 数码 图书 小吃 小吃 

修改后的数据：
图书 小吃 数码

 

 

 

adding：

Jupyter Notebook文件地址设置：

1.打开cmd,输入 jupyter notebook --generate-config 

2.打开这个配置文件，找到“c.NotebookApp.notebook_dir=‘’ ”，去掉前面的#号， 把路径改成自己的工作目录

3.配置文件修改完成后， 以后在jupyter notebook中写的代码等都会保存在 自己创建的目录中。

按以上操作之后重启Jupyter Notebook可能无效，解决方法如下：

jupyter notebook->右键->属性->将目标中的%users%去掉

 

arr=np.array([u'数学',u'语文'])不能显示字符可以在前面加u

 

jupyter上方有的Cell,里面的cell all可以一次性执行所有步骤