Numpy和Pandas的学习总结

学习完莫烦python. numpy和pandas;学习总结，【Numpy & Pandas (数据处理教程)】

1、创建一个二维数组

np.array()

import numpy as np
array = np.array([[1, 2, 3],
                  [2, 3, 4]])
print(array)
print("number of dim:", array.ndim)  #数组有几行，就是几维  这里为2行（2维）
print("shape:", array.shape)  #数组形状，二行三列
print("size:", array.size)  #有多少元素在数组中

2、创建

np.zeros(); np.ones(); np.empty(); np.arange(); np.linspace();

import numpy as np
# a = np.array([1, 2, 3, 4], dtype=np.int)  #dtype数组元素为什么类型，例如,int float
a = np.array([1, 2, 3, 4], dtype=np.int64)  #现在为np.int_  代表32位， np.int64  代表63位
print(a.dtype)

b = np.zeros((3, 4))   #定义3行4列全为0的矩阵
print(b)

c = np.ones( (3, 4), dtype=np.int16)  #定义3行4列全为1的矩阵
print(c)

d = np.empty( (3, 4))  #生成什么都没有的空矩阵，实际值无限接近0
print(d)

e = np.arange(10, 20, 2)  #取值[10,20],步长为2
print("这里是e:\n", e)

f = np.arange(12).reshape( (3, 4)) #生成12个元素，矩阵为3行4列
print("这里是f:\n", f)

g = np.linspace(1, 10, 20)   #生成[1,10]数列（线段），有20段
print("g:\n", g)

g = np.linspace(1, 10, 20).reshape( (4, 5))   #生成[1,10]数列（线段），有20段，矩阵为4行5列
print("g:\n", g)

3、矩阵的基本运算

np.arange(4).reshape( (2,2))；
np.dot(a, b) #矩阵相乘
np.random.random((2,4)) 随机生成一个矩阵

import numpy as np
a = np.array([10, 20, 30, 40])
b = np.arange(4)   #生成0-3的矩阵
print(a, b)
c = a-b
print(c)

c= b**4 #b矩阵的4次方
print(c)

c = 10*np.sin(a)
print(c)

print(b<3)

a = np.array([[1, 1],
              [0, 1]])
b = np.arange(4).reshape( (2,2))
print(a)
print(b)
#乘法
c = a*b #逐个相乘
c_dot = np.dot(a, b)   #矩阵相乘
c_dot_2 = a.dot(b)    #和上面计算相同
print("乘法\n", c)
print(c_dot)
print(c_dot_2)

#随机生成一个矩阵
a = np.random.random((2,4))
print("随机生成矩阵：", a)
print(np.sum(a))
print(np.min(a))
print(np.max(a))
print(np.sum(a, axis=1))  #axis=1代表每一行的值
print(np.min(a, axis=0))  #axis=0代表每一列的最小值

4、

import numpy as np

A = np.arange(2, 14).reshape((3, 4))
print(np.argmin(A))  #A矩阵最小值的索引（即坐标）
print(np.mean(A))    #A矩阵的平均值
print(A.mean())    #A矩阵的平均值
print(np.median(A))    #矩阵的中位数
print(np.cumsum(A))    #A矩阵逐步累加的过程
print(np.diff(A))    #A矩阵逐步累差（减）的过程
print(np.nonzero(A))   #A矩阵非0的数
print(np.sort(A))    #A矩阵排序
print(np.transpose(A))   #A矩阵的反向，行变为列，列变为行 ，转置
print(np.clip(A, 5, 9))  #A矩阵的所有小于5的数都等于5，大于9的数都等于9

5、矩阵的显示

import numpy as np

A = np.arange(3, 15)
print(A)
print(A[2])

A = np.arange(3, 15).reshape((3, 4))
print(A)
print(A[2])   #显示第3行
print(A[1][1])  #显示第2行第2列
print(A[1, 1])  #显示第2行第2列
print(A[1, :])  #显示第2行所有数
print(A[1, 1:3])  #显示第2行第2列到第3列的数

print(A.flat)   #A矩阵的向
for item in A.flat:
    print(item)

6、矩阵的合并

np.vstack((A, B)) #将A和B合并为2维矩阵；
np.hstack((A, B)) #将A和B合并列矩阵

import numpy as np

A = np.array([1, 1, 1])
B = np.array([2, 2, 2])
C = np.vstack((A, B))   #将A和B合并为2维矩阵
D = np.hstack((A, B))   #将A和B合并列矩阵 [1 1 1 2 2 2]
print(C)
print(D)

print(A[:, np.newaxis])   #将一维向量转变为纵向
A = A[:, np.newaxis]
B = B[:, np.newaxis]
C = np.vstack((A, B))   #将A和B合并为6行1列矩阵
D = np.hstack((A, B))   #将A和B合并列矩阵 3行2列矩阵
print(C)
print(D)

C = np.concatenate((A,B,B,A), axis=0)  #将这几个矩阵在列向量合并
print(C)

7、矩阵的分割

np.split(A, 2, axis=1) 将矩阵A分割为2个矩阵，按照列分割
np.array_split(A, 3, axis=1) 将3行4列矩阵A分割为3个矩阵，按照列分割，这样其中一个矩阵为3行2列

import numpy as np

A = np.arange(12).reshape((3, 4))
print(A)
print(np.split(A, 2, axis=1))   #将矩阵A分割为2个矩阵，按照列分割
print(np.split(A, 3, axis=0))   #将矩阵A分割为3个矩阵，按照行分割
print(np.array_split(A, 3, axis=1))   #将3行4列矩阵A分割为3个矩阵，按照列分割，这样其中一个矩阵为3行2列
print(np.vsplit(A,3))       #将矩阵A分割为3个矩阵，按照行分割
print(np.hsplit(A,2))       #将矩阵A分割为2个矩阵，按照列分割

8、矩阵赋值和关联的区别

e.copy() #只是赋值，而不是关联

import numpy as np
a = np.arange(4)
print(a)
b = a;
c = a;
d = b;
print(a,b,c,d)
a[0] = 11
print(a,b,c,d)  #改变a中的元素，b,c,d也会跟着改变，这和c语言是不一样的；同样的改变b,c,d中任意一个的值，a,b,c,d都会改变

#让a,b,c,d改变不会对其他影响
e = np.arange(4)
f = e.copy()  #只是赋值，而不是关联
print(e,f)
e[0] = 22
print(e, f)

9、pandas系列

pd.date_range();
pd.Series();
pd.DataFrame();

import pandas as pd
import numpy as np

s = pd.Series([1, 3, 6, np.nan, 44, 1])  #np.nan表示一个空值
print(s)

dates = pd.date_range('20220110',periods=6)
print(dates)

#下面的6行4列矩阵，行索引为日期，列索引为字符a,b,c,d
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=['a', 'b', 'c', 'd'])
print(df)
print(df.index)  #打印索引
print(df.columns)   #打印列索引
print(df.values)    #打印整个矩阵，不显示索引
print(df.describe())  #基本的值，包含个数，平均值，最小值，最大值
print(df.T)    #df矩阵转置
print(df.sort_index(axis=1, ascending=False))   #将列序列逆排序
print(df.sort_values(by='b'))  #将b列值排列

10、按照索引显示

df.loc[] ; 按照标签的形式显示
df.iloc[]; 按照位置的形式显示

import pandas as pd
import numpy as np

dates = pd.date_range('20220110', periods=6)
#下面的6行4列矩阵，行索引为日期，列索引为字符a,b,c,d
df = pd.DataFrame(np.arange(24).reshape((6,4)), index=dates, columns=['a', 'b', 'c', 'd'])
print(df['a'], df.a)   #两种打印方式是一致的
print(df[0:3])    #显示[0,2]行数据

#按照标签的形式显示
print("按照标签的形式显示")
print(df.loc['20220111'])
print(df.loc[:, ['a', 'b']])  #打印列中a,b两列
print(df.loc['20220111', ['a', 'b']])  #打印列中a,b两列，只显示20220111这一行

#按照位置的形式显示
print("按照位置的形式显示")
print(df.iloc[3, 1])     #显示第三行第一列数据
print(df.iloc[3:5, 1:3])     #显示第三行到第五行，第一列到第三列数据
print(df.iloc[[1, 3, 5], 1:3])     #显示第1行,第3行,第五行，第一列到第三列数据

#按照位置和标签的混合形式显示,python3中已经弃用了ix标签
# print("按照位置和标签的混合形式显示")
# print(df.ix[:3, ['a','c']])

print("打印需要判断的值")
print(df)
print(df[df.a > 8])  #打印a列中大于8的值

11、对矩阵中具体坐标的数值改变

import pandas as pd
import numpy as np

dates = pd.date_range('20220110', periods=6)
#下面的6行4列矩阵，行索引为日期，列索引为字符a,b,c,d
df = pd.DataFrame(np.arange(24).reshape((6,4)), index=dates, columns=['a', 'b', 'c', 'd'])

print("种方式改变数组中的值")
print(df)
df.iloc[2, 2] = 1111
df.loc['20220111', 'b'] = 2222
print(df)
df.b[df.b > 0] = 0  #将b列大于0的数全部改为0
print(df)

12、对于矩阵中有空值的处理

df.dropna(); 对矩阵中有空值的进行丢弃
df.isnull(); 是否有数据为空值
df.fillna(); 填充空值处为具体数值

import pandas as pd
import numpy as np

dates = pd.date_range('20220110', periods=6)
#下面的6行4列矩阵，行索引为日期，列索引为字符a,b,c,d
df = pd.DataFrame(np.arange(24).reshape((6,4)), index=dates, columns=['a', 'b', 'c', 'd'])
print("处理丢失的数据")
df.iloc[0, 1] = np.nan
df.iloc[1, 2] = np.nan
print(df)

print("把数据有丢失的，按照行丢失")
print(df.dropna(axis=0, how='any'))  #how={'any','all'} any代表这一行只要有一个数据为空值就丢弃，
                                     # all代表这一行所有值都为空值才会把这一行丢弃
print(df.isnull())  #是否有数据为空值，显示整个矩阵
print(np.any(df.isnull()) == True)  #是否有数据为空值，只返回一个判断值
print("把数据有丢失的，把丢失的数据填上一个值")
print(df.fillna(value=0))

13、对矩阵的不同方式合并

pd.concat();
df1.append();

import pandas as pd
import numpy as np

df1 = pd.DataFrame(np.ones((3, 4))*0, columns=['a', 'b', 'c', 'd'])
df2 = pd.DataFrame(np.ones((3, 4))*1, columns=['a', 'b', 'c', 'd'])
df3 = pd.DataFrame(np.ones((3, 4))*2, columns=['a', 'b', 'c', 'd'])
print(df1)
print(df2)
print(df3)
print("把三个矩阵进行合并")

res = pd.concat([df1, df2, df3], axis=0)  #列合并,索引（即坐标）还为以前的坐标
print(res)
res = pd.concat([df1, df2, df3], axis=0, ignore_index=True)  #列合并,索引（即坐标）为顺序排列的
print(res)

#索引为1，2，3
df4 = pd.DataFrame(np.ones((3, 4))*0, columns=['a', 'b', 'c', 'd'], index=[1, 2, 3])
#索引为2，3，4
df5 = pd.DataFrame(np.ones((3, 4))*1, columns=['b', 'c', 'd', 'e'], index=[2, 3, 4])
print(df4)
print(df5)
res = pd.concat([df4, df5])   #没有值的索引为空值
print(res)
res = pd.concat([df4, df5], join='inner')  #保留两个矩阵中有共同索引的值
print(res)

print("append把一个矩阵加入到另一个矩阵中")
res = df1.append(df2, ignore_index=True) #加一个矩阵
print(res)
res = df1.append([df2, df3], ignore_index=True) #加多个矩阵
print(res)

print("给一个矩阵添加一行")
s1 = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
res = df1.append(s1, ignore_index=True)
print(res)

14、矩阵合并-2

pd.merge();

import pandas as pd

left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                     'A': ['A0', 'A1', 'A2', 'A3'],
                     'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                      'C': ['C0', 'C1', 'C2', 'C3'],
                      'D': ['D0', 'D1', 'D2', 'D3']})
print(left)
print(right)
res = pd.merge(left, right, on='key')  #基于key列合并
print(res)

#有两个关键列，key1,key2
left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
                     'key2': ['K0', 'K1', 'K0', 'K1'],
                     'A': ['A0', 'A1', 'A2', 'A3'],
                     'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
                      'key2': ['K0', 'K0', 'K0', 'K0'],
                      'C': ['C0', 'C1', 'C2', 'C3'],
                      'D': ['D0', 'D1', 'D2', 'D3']})
print(left)
print(right)
# how = {'left', 'right', 'outer', 'inner'}
#outer是把所有的索引都添加进来，没有的值为空值； inner是把有交集的索引集合起来，没有的丢弃

res = pd.merge(left, right, on=['key1', 'key2'], how='inner')
print(res)

15、matplotlib画图

data.plot()
plt.show()；
data.plot.scatter();
data.plot.scatter();

import pandas as pd
import numpy as np
import matplotlib .pyplot as plt

data = pd.Series(np.random.randn(1000), index=np.arange(1000))
data = data.cumsum()
data.plot()
plt.show()

data = pd.DataFrame(np.random.randn(1000, 4),
                    index = np.arange(1000),
                    columns=list("ABCD"))
data = data.cumsum()
data.plot()
plt.show()

#散点图
ax = data.plot.scatter(x='A', y='B', color='DarkBlue', label='Class 1')
data.plot.scatter(x='A', y='C', color='DarkGreen', label='Class 2', ax=ax)
plt.show()