Pandas and Numpy

import pandas as pd
import numpy as np

a = np.array([2,3,4])
b = np.array([2.0,3.0,4.0])
c = np.array([[1.0,2.0],[3.0,4.0]])
d = np.array([[1,2],[3,4]],dtype=complex) # 指定数据类型
print(a, a.dtype)
print(b, b.dtype)
print(c, c.dtype)
print(d, d.dtype)

array:创建数组，([数组])

dtype为数据类型

结果：

[2 3 4] int32
[2. 3. 4.] float64
[[1. 2.]
 [3. 4.]] float64
[[1.+0.j 2.+0.j]
 [3.+0.j 4.+0.j]] complex128

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

print(np.arange(0,7,1,dtype=np.int16)) # 0为起点，间隔为1时可缺省(引起歧义下不可缺省)
print(np.ones((2,3,4),dtype=np.int16)) # 全为1 2页，3行，4列，全1，指定数据类型
print(np.zeros((2,3,4))) # 全为0 2页，3行，4列，全0
print(np.empty((2,3))) #值取决于内存
print(np.arange(0,10,2)) # 起点为0，不超过10，步长为2
print(np.linspace(-1,2,5)) # 起点为-1，终点为2，取5个点（实际上是五个数，不过分开了）
print(np.random.randint(0,3,(2,3))) # 大于等于0，小于3，2行3列的随机整数

arange：类似于循环生成，从0-6，一行。

np.ones用1填充，2页就是其大数组有两个，每个都是三行四列。

np.zeros用0填充，2页就是其大数组有两个，每个都是三行四列。

random的（0，3，（2，3））为0-3的2行三列的随机数。

结果：

[0 1 2 3 4 5 6]


[[[1 1 1 1]
  [1 1 1 1]
  [1 1 1 1]]
 [[1 1 1 1]
  [1 1 1 1]
  [1 1 1 1]]]


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

[[1.39069238e-309 1.39069238e-309 1.39069238e-309]
 [1.39069238e-309 1.39069238e-309 1.39069238e-309]]
[0 2 4 6 8]
[-1.   -0.25  0.5   1.25  2.  ]
[[0 2 0]
 [2 0 1]]

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

## 非数组运算，调用方法
a = np.random.randint(0,5,(2,3))
print(a)
print(a.sum(),a.sum(axis=1),a.sum(0))  # axis用于指定运算轴（默认全部，可指定0或1）
print(a.min(),a.max(axis=1),a.mean(axis=1))  # axis = 0: 按列计算，axis = 1: 按行计算
print(a.cumsum(1))  # 按行计算累积和

axis：轴

默认0 按照整列 可以想象成竖着的长方形框起数据

指定1 按照整行 可以想象成横着的长方形

a先为一个0-5的随机数的2行三列的数组

a.sum()为累加所有值，a.min()为取出最小值

a.sum(axis=1)为按照按照行来进行累加并且输出一个数组（默认为0，按照列）

a.sum(0)就是默认

cumsum类似于斐波那契

a.mean(axis=1)按照行来计算平均值并输出为一个数组

结果：

[[4 4 3]
 [3 4 1]]
19 [11  8] [7 8 4]
1 [4 4] [3.66666667 2.66666667]
[[ 4  8 11]
 [ 3  7  8]]

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

a = np.array([10,20,30,40])
b = np.arange(4)
print(a)
print(b)

结果

[10 20 30 40]
[0 1 2 3]

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

A = np.arange(2,14)
print(A)
A = np.arange(2,14).reshape(3,4)
print(A)

结果

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

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

numpy.dot(object1,object2)

或者object1.dot(object2)

乘法（不是矩阵乘法！）

仅仅是每一个列进行对应相乘再相加，输出一个值。

# 矩阵的乘法
c = np.dot(a,b)
# 或者c = a.dot(b)
print(c)

结果为200

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

A = np.arange(1,10,2) #步长为2
A = np.array([[10,20,30,40],[50,60,70,80],[10,20,30,40]])
print(A)

print(np.mean(A))# 平均数
print(A.mean())# 或者这种平均数
print(np.median(A))# 矩阵中间值
print(np.cumsum(A)) #斐波那契数列累加
print(np.diff(A))#逐差
print(np.nonzero(A))#索引指出非零的数 第一个是什么行 第二个是什么列
print(np.sort(A))#逐行排序
print(np.transpose(A))#矩阵的转置
print((A.T).dot(A))#???????
print(np.clip(A,5,9))#小于5的都等于5，大于9的都等于9
print(np.mean(A,axis=0))#可以进行列的平均计算。

nonzero返回非零数的索引，第一个数组是非零数行的索引，第二个数组是对应的列的索引

(A.T).dot(A)计算矩阵的内积 

结果：

[[10 20 30 40]
 [50 60 70 80]
 [10 20 30 40]]
38.333333333333336
38.333333333333336
35.0
[ 10  30  60 100 150 210 280 360 370 390 420 460]
[[10 10 10]
 [10 10 10]
 [10 10 10]]
(array([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2], dtype=int64), array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3], dtype=int64))
[[10 20 30 40]
 [50 60 70 80]
 [10 20 30 40]]
[[10 50 10]
 [20 60 20]
 [30 70 30]
 [40 80 40]]
[[2700 3400 4100 4800]
 [3400 4400 5400 6400]
 [4100 5400 6700 8000]
 [4800 6400 8000 9600]]
[[9 9 9 9]
 [9 9 9 9]
 [9 9 9 9]]
[23.33333333 33.33333333 43.33333333 53.33333333]

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

A = np.arange(3,15).reshape(3,4)
print(A)
print(A[2])#以索引进行获取值 获取的是索引为2的行
print(A[0,0])#索引准确值 例如一行的第一列
print(A[:,1])#第一列的所有数
print(A[1,1:3])#第二行1-3的数

reshape:进行形状限定，3，4为三行四列

结果：

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

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

print(A)
for row in A:
    print(row)#逐行进行打印

进行逐行取出：

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

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

print(A.T)
for column in A.T:
    print(column)#转置后再抽取各个行 就实现了抽取各个列。

print(A.flatten())#A变成只有一行的
for item in A.flat:
    print(item)

column的意思为列。

flatten转为一个数组，只有一列。

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

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

# 合并
A = np.array([[1,1,1]])
B = np.array([[2,2,2]])

print('A,B',np.vstack((A,B))) #合并矩阵

C = np.vstack((A,B))
print('A',A.shape,'C',C.shape) #打印形状

D = np.hstack((A,B)) #序列的整行合并
print('D',D)
print(D.shape)

# 如果想把一个横向的数列变成竖向的数列，我们不能用.T来表示，此reshape不能抓换。

AA = np.array([1,1,1]) #此AA不为一个矩阵了？

print(AA[np.newaxis,:])#在行上加一个维度[[1 1 1]]

print(AA[:,np.newaxis])#在纵向上加一个维度

print(AA.reshape(3,1)) #也可以

np.vstack((A,B)数组的合并

hstack整行合并

A.shape形状

np.newsxis加一个维度

Object[np.newsxis,:]行上加一个维度，原来是单数组，现在是【单数组】

如果是np.array([[3,3,3]])

则纵向加轴和横向加轴 结果都一样 为[[[3,3,3]]] 

如果想要纵向加轴，只能reshape。

A,B 
[[1 1 1]
 [2 2 2]]

A (1, 3) C (2, 3)

D [[1 1 1 2 2 2]]

(1, 6)

[[1 1 1]]

[[1]
 [1]
 [1]]


[[1]
 [1]
 [1]]

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

在NumPy中，np.array([[1,1,1]]) 和 np.array([1,1,1]) 之间有一些重要的区别：

形状（Shape）：
np.array([[1,1,1]]) 是一个形状为 (1, 3) 的二维数组，即它有一行和三列。
np.array([1,1,1]) 是一个形状为 (3,) 的一维数组，即它只有一个轴，包含三个元素。

维度（Dimension）：
np.array([[1,1,1]]) 是一个二维数组，因为它有两个轴。
np.array([1,1,1]) 是一个一维数组，因为它只有一个轴。

访问元素的方式：
对于二维数组 np.array([[1,1,1]])，你可以通过行和列的索引来访问元素，例如 array[0, 1]。
对于一维数组 np.array([1,1,1])，你只能使用单个索引来访问元素，例如 array[1]。
在使用NumPy时，了解数组的形状和维度非常重要，因为它们会影响到数组的操作和行为。

C = np.concatenate((A,B,A,B)) #多个横向合并
print('C',C)

C = np.concatenate((A,B,B,A),axis=0)
print(C)

C = np.concatenate((A,B,B,A),axis=1)
print(C)

print('================================================================================================================')
A = np.arange(12).reshape(3,4)
print(A)

print(np.split(A,2,axis=1)) #纵向的分割，分成对等的两块。
print('++++++++')
print(np.split(A,3,axis=0)) #横向的分割，分成三块。

# ！！！！！！！！！分割函数不能不等量的分割。

print('++++++++不等量分割')
print(np.array_split(A,3,axis=1))#不等量分割
print(np.vsplit(A,3))
print(np.hsplit(A,2))

1

C [[1 1 1]
 [2 2 2]
 [1 1 1]
 [2 2 2]]
[[1 1 1]
 [2 2 2]
 [2 2 2]
 [1 1 1]]
[[1 1 1 2 2 2 2 2 2 1 1 1]]
=========================================================================================
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11]])]
++++++++
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
++++++++不等量分割
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2],
       [ 6],
       [10]]), array([[ 3],
       [ 7],
       [11]])]
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11]])]