一、Numpy中ndarray的创建

1、一维数组与二维数组的创建

import numpy as np
# numpy创建一维数组
a = np.array([1, 2, 3])
print(a)
# numpy创建二维数组
b = np.array([[1, 2, 3],
                [4, 5, 6]])
print(b)

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

2、创建ndarray传入的参数

# numpy既可以传入列表，又可以传入一个元组
a = np.array([1, 2, 3, 4])
print(a)
b = np.array((4, 5, 6, 7))
print(b)

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

3、创建时传入参数的类型相同

# numpy中传入参数的类型是一样的，是整形全是整形，是浮点全是浮点。
a = np.array([1, 2, 3.0])
print(a)
print(a.dtype)

[ 1.  2.  3.]
float64

4、利用np.arange()函数创建数组

# 利用np.arange()函数创建ndarray
# 第一个参数是从哪个数字开始，第二个参数是终止数字，第三个参数是数字之间的间隔
a = np.arange(1,100,10)
print(a)

[ 1 11 21 31 41 51 61 71 81 91]

5、创建全为0的矩阵

# 创建一个全为0的矩阵,第一个参数为行的数目，第二个参数为列的数目，dtype为元素的数据类型
a = np.zeros ((3,4), dtype=np.int32)
print(a)

[[0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]]

6、创建全为1的矩阵

# 创建一个全为1的矩阵，与创建全为0矩阵的操作一样。
a = np.ones((4,5), dtype=str)
print(a)

[['1' '1' '1' '1' '1']
 ['1' '1' '1' '1' '1']
 ['1' '1' '1' '1' '1']
 ['1' '1' '1' '1' '1']]

7、创建指定元素个数的矩阵

# 创建指定元素个数的矩阵，元素的大小在第一个参数与第二个参数之间，第三个参数为元素个数
a = np.linspace( 0, 2, 100)
print(a)

[ 0.          0.02020202  0.04040404  0.06060606  0.08080808  0.1010101
  0.12121212  0.14141414  0.16161616  0.18181818  0.2020202   0.22222222
  0.24242424  0.26262626  0.28282828  0.3030303   0.32323232  0.34343434
  0.36363636  0.38383838  0.4040404   0.42424242  0.44444444  0.46464646
  0.48484848  0.50505051  0.52525253  0.54545455  0.56565657  0.58585859
  0.60606061  0.62626263  0.64646465  0.66666667  0.68686869  0.70707071
  0.72727273  0.74747475  0.76767677  0.78787879  0.80808081  0.82828283
  0.84848485  0.86868687  0.88888889  0.90909091  0.92929293  0.94949495
  0.96969697  0.98989899  1.01010101  1.03030303  1.05050505  1.07070707
  1.09090909  1.11111111  1.13131313  1.15151515  1.17171717  1.19191919
  1.21212121  1.23232323  1.25252525  1.27272727  1.29292929  1.31313131
  1.33333333  1.35353535  1.37373737  1.39393939  1.41414141  1.43434343
  1.45454545  1.47474747  1.49494949  1.51515152  1.53535354  1.55555556
  1.57575758  1.5959596   1.61616162  1.63636364  1.65656566  1.67676768
  1.6969697   1.71717172  1.73737374  1.75757576  1.77777778  1.7979798
  1.81818182  1.83838384  1.85858586  1.87878788  1.8989899   1.91919192
  1.93939394  1.95959596  1.97979798  2.        ]

8、创建随机数字组成的矩阵

# 利用numpy中的random方法生成0-1的随机数字组成的矩阵
a = np.random.random((3,4))
print(a)

[[ 0.98345823  0.22998123  0.3184805   0.35060373]
 [ 0.57452505  0.90753255  0.44305263  0.89099682]
 [ 0.74883429  0.38138843  0.74271146  0.51948479]]

二、Numpy中数组的索引

1、创建ndarray

import numpy as np
a = np.arange(10)
print(a)
print("-------")
b = np.arange(9).reshape(3,3)
print(b)
# 打印一下维度的个数
print(b.ndim)
# 打印一下数据类型
print(b.dtype.name)
# 打印一下元素个数
print(b.size)

[0 1 2 3 4 5 6 7 8 9]
-------
[[0 1 2]
 [3 4 5]
 [6 7 8]]
2
int32
9

2、一维数组的直接索引

# 一维数组的直接索引
print(a[0])

0

3、二维数组的直接索引

# 二维数组的直接索引
print(b[0][0])
print(b[0,0])

0
0

4、一维数组的布尔索引

# 一维数组的布尔索引
print(a>=3)
print(a[a>=3])

[False False False  True  True  True  True  True  True  True]
[3 4 5 6 7 8 9]

5、二维数组的布尔索引

# 二维数组的布尔索引，在各个维度上做一维的布尔索引
index = (b[:,1] == 4)
print(index)
print(b[index, :])

[False  True False]
[[3 4 5]]

6、逻辑操作符的使用

# "&"与"|"逻辑操作符的使用，一定要记得加上括号，防止逻辑结构出现混乱
print(a[(a>=3) & (a<=5)])
print(a[(a>=3) | (a<=5)])

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

三、Numpy中数组的切片

1、创建ndarray

import numpy as np
a = np.arange(10)
print(a)
# 打印数组的shape
print(a.shape)
# 打印数组的数据类型
print(a.dtype)
print("-------")
# 利用reshape方法可以转化数组的维度
b = np.arange(12).reshape(3,4)
print(b)
# 打印数组的shape
print(b.shape)
# 打印数组的数据类型
print(b.dtype)

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

2、一维数组的切片

# 一维数组的切片，包括第一个数字，但是不包括最后一个数字
print(a[0:3])
# 一维数组逆向索引
print(a[0:-1])
print(a[0:-2])
# 一纬数组的拷贝
print(a[:])

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

3、二维数组的切片

# 二维数组的切片,第一个维度与第二个维度用","隔开，在各个维度上做一维数组的切片
print(b[1:4,2:4])
# 取二维数组中的一维数组
print(b[1:4,2])

[[ 6  7]
 [10 11]]
[ 6 10]

4、多维数组的切片

多维数组的切片可以类比二维数组的切片

四、Numpy中数组的运算

1、创建ndarray

import numpy as np
a = np.arange(10)
b = np.arange(10)
print(a)
print(b)
print("--------")
c = np.array(
            [
            [1, 2, 3],
            [4, 5, 6],
            [7, 8, 9]
            ])
print(c)
print(c.dtype)
print("--------")
# 转化ndarray的数据类型
c = c.astype("float")
print(c)
print(c.dtype)

[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]
--------
[[1 2 3]
 [4 5 6]
 [7 8 9]]
int32
--------
[[ 1.  2.  3.]
 [ 4.  5.  6.]
 [ 7.  8.  9.]]
float64

2、一维数组与一维数组运算

# 一维数组与一维数组的运算
# 加法
print(a+b)
# 减法
print(a-b)
# 乘法
print(a*b)
# 求和
print(a.sum())
# 平方
print(a**2)

[ 0  2  4  6  8 10 12 14 16 18]
[0 0 0 0 0 0 0 0 0 0]
[ 0  1  4  9 16 25 36 49 64 81]
45
[ 0  1  4  9 16 25 36 49 64 81]

3、二维数组的运算

# 二维数组的运算
d = np.array([1, 2, 3])
# 矩阵乘法
print(np.dot(d,c))
# 在第一个维度和第二个维度上求和，axis=0是在列上相加，axis=1是在行上相加#
print(c.sum(axis=0))
print(c.sum(axis=1))

[ 30.  36.  42.]
[ 12.  15.  18.]
[  6.  15.  24.]

4、数组求指数函数和开根号

# 数组求指数函数和开根号
print(np.exp(a))
print(np.sqrt(a))

[  1.00000000e+00   2.71828183e+00   7.38905610e+00   2.00855369e+01
   5.45981500e+01   1.48413159e+02   4.03428793e+02   1.09663316e+03
   2.98095799e+03   8.10308393e+03]
[ 0.          1.          1.41421356  1.73205081  2.          2.23606798
  2.44948974  2.64575131  2.82842712  3.        ]

5、数组的叠加

# 数组的叠加
e = np.arange(9).reshape(3,3)
print(e)
print("---------")
# 数组横向的叠加，注意参数为元组的形式
print(np.hstack((c, e)))
# 数组纵向的叠加
print(np.vstack((c, e)))
print("---------")
# 数组以倍数形式叠加，第二个参数为元组形式，一个指行扩大几倍，一个指列扩大几倍
f = np.tile(a, (3, 1))
print(f)

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

6、将二维或多维数组展成一维数组

# 将二#维或者多维数组展平为一维数组
print(b.ravel())

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

7、数组的拆分

# 数组的拆分
# 按照行拆分
print(np.vsplit(c, 3))
print("---------")
# 按照列拆分
print(np.hsplit(c, 3))
print("--------")
# 按照固定位置拆分
print(np.vsplit(c, (1,2)))

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

8、数组的排序

# 数组的排序
# 直接排序
g = np.array(
            [
            [6,4,515],
            [7,98,33]
            ]
            )
print(np.sort(g, axis=1))
print(np.sort(g, axis=0))
print("--------")
# 先找出索引，然后排序
t = np.array([3,7,2,53,8])
print(np.argsort(t))
print(t[np.argsort(t)])

[[  4   6 515]
 [  7  33  98]]
[[  6   4  33]
 [  7  98 515]]
--------
[2 0 1 4 3]
[ 2  3  7  8 53]

五、数组的拷贝

1、数组的复制

import numpy as np
a = np.arange(10)
print(a)
# 将a的值赋值给b
b = a
# 一开始a与b的地址是相同的
print(id(b))
print("---------")
# 改变b后发现a也发生了改变
b.shape = 2,5
print(a.shape)
print("---------")
print(id(b))
print(id(a))

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

2、数组的浅拷贝

# 利用view方法可以实现浅拷贝，发现c与a的地址会不一样。
c = a.view()
print(c is a)
print(id(a))
print(id(c))
print("-------")
# 当改变c内元素的值时发现a也改变了
c[0,0] = 7
print(a)

False
2443354975488
2443354974208
-------
[[7 1 2 3 4]
 [5 6 7 8 9]]

3、数组的深拷贝

# 利用copy方法实现深拷贝，发现d的地址与a的地址会不一样。
d = a.copy()
print(id(d))
print(id(a))
print("--------")
# 当改变d内元素的值时发现，a的值没有改变。
d[0,0]=1111
print(a)
print(d)

2443355026256
2443354975488
--------
[[7 1 2 3 4]
 [5 6 7 8 9]]
[[1111    1    2    3    4]
 [   5    6    7    8    9]]