1、Numpy & Pandas简介
应用
- 数据分析
- 机器学习
- 深度学习
为什么使用 numpy & pandas
- 运算速度快：numpy 和 pandas 都是采用 C 语言编写, pandas 又是基于 numpy, 是 numpy 的升级版本。
- 消耗资源少：采用的是矩阵运算，会比 python 自带的字典或者列表快好多
2、 Numpy学习
2.1 numpy的属性：
- ndim：维度
- shape：行数和列数
- size：元数个数
import numpy as np
array = np.array([[1,2,3],[2,3,4]]) #列表转化为矩阵
print(array)
print('number of dim:',array.ndim) # 维度
# number of dim: 2
print('shape :',array.shape) # 行数和列数
# shape : (2, 3)
print('size:',array.size) # 元素个数
# size: 6
[[1 2 3]
[2 3 4]]
number of dim: 2
shape : (2, 3)
size: 6
2.2 Numpy的创建array
-
关键字
- array：创建数组
- dtype：指定数据类型
- zeros：创建数据全为0
- ones：创建数据全为1
- empty：创建数据接近0
- arrange：按指定范围创建数据
- inspace：创建线段
-
创建数组
a = np.array([2,23,4]) # list 1d
print(a)
[ 2 23 4]
- 指定数据dtype
科普计算机的基本存储单元
（1）位（bit）：二进制数中的一个数位，可以是0或者1，是计算机中数据的最小单位。二进制的一个“0”或一个“1”叫一位。
（2）字节（Byte，B）：计算机中数据的基本单位，每8位组成一个字节。各种信息在计算机中存储、处理至少需要一个字节。
8 bit = 1 Byte
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rsXkl5nS-1610281931746)(attachment:image.png)]
a = np.array([2,23,4],dtype=np.int)
print(a.dtype)
int32
a = np.array([2,23,4],dtype=np.int64)
print(a.dtype)
int64
a = np.array([2,23,4],dtype=np.float)
print(a.dtype)
# float64
float64
a = np.array([2,23,4],dtype=np.float32)
print(a.dtype)
# float32
float32
- 创建特定数据
a = np.array([[2,23,4],[2,32,4]]) # 2d 矩阵 2行3列
print(a)
[[ 2 23 4]
[ 2 32 4]]
a = np.zeros((3,4)) # 数据全为0，3行4列
print(a)
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
a = np.ones((3,4),dtype = np.int) # 数据为1，3行4列
print(a)
[[1 1 1 1]
[1 1 1 1]
[1 1 1 1]]
a = np.empty((3,4)) # 数据为empty，3行4列
print(a)
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
a = np.arange(10,20,2) # 10-19 的数据(左闭右开)，2步长（步长不设置则默认为1）
print(a)
[10 12 14 16 18]
a = np.arange(12).reshape((3,4)) # 3行4列，0到11
print(a)
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
a = np.linspace(1,10,20) # 开始端1，结束端10，且分割成20个数据，生成线段
print(a)
[ 1. 1.47368421 1.94736842 2.42105263 2.89473684 3.36842105
3.84210526 4.31578947 4.78947368 5.26315789 5.73684211 6.21052632
6.68421053 7.15789474 7.63157895 8.10526316 8.57894737 9.05263158
9.52631579 10. ]
a = np.linspace(1,10,20).reshape((5,4)) # 更改shape
print(a)
[[ 1. 1.47368421 1.94736842 2.42105263]
[ 2.89473684 3.36842105 3.84210526 4.31578947]
[ 4.78947368 5.26315789 5.73684211 6.21052632]
[ 6.68421053 7.15789474 7.63157895 8.10526316]
[ 8.57894737 9.05263158 9.52631579 10. ]]
## 2.3 Numpy的基础运算
- 一维矩阵运算
import numpy as np
a=np.array([10,20,30,40]) # array([10, 20, 30, 40])
b=np.arange(4) # array([0, 1, 2, 3])
#矩阵减法
c=a-b
print('矩阵减法：',c)
#矩阵加法
c=a+b
print('矩阵加法：',c)
##矩阵乘法
c=a*b
print('矩阵乘法：',c)
#矩阵乘方
c=b**2
print('矩阵乘方；',c)
#矩阵的三角函数
c=10*np.sin(a)
print('矩阵的三角函数：',c)
#print中逻辑判断
print(b<3)
矩阵减法： [10 19 28 37]
矩阵加法： [10 21 32 43]
矩阵乘法： [ 0 20 60 120]
矩阵乘方； [0 1 4 9]
矩阵的三角函数： [-5.44021111 9.12945251 -9.88031624 7.4511316 ]
[ True True True False]
- 二维矩阵运算
a=np.array([[1,1],[0,1]])
b=np.arange(4).reshape((2,2))
print('矩阵a：',a,'\n','矩阵b：',b)
# 矩阵对应元素相乘
c=a*b
print('对应元素相乘：',c)
# 矩阵点乘
c_dot = np.dot(a,b)
c_dot_2 = a.dot(b) #两种写法都可以
print('矩阵点乘：',c_dot)
矩阵a： [[1 1]
[0 1]]
矩阵b： [[0 1]
[2 3]]
对应元素相乘： [[0 1]
[0 3]]
矩阵点乘： [[2 4]
[2 3]]
import numpy as np
a=np.random.random((2,4))
print(a)
[[0.89280045 0.40822491 0.84933252 0.86478089]
[0.27147445 0.78042731 0.73171587 0.27361339]]
# 求和、求最大、求最小元素
sum=np.sum(a)
max=np.max(a)
min=np.min(a)
print(sum,max,min)
5.072369781894403 0.8928004524212831 0.27147444901216167
# 对行或列查找
print("sum =",np.sum(a,axis=1)) # 第一行的和、第二行的和
print("min =",np.min(a,axis=0)) # 每一列的最小值
print("max =",np.max(a,axis=1)) # 每一行的最大值
#当axis的值为0的时候，将会以列作为查找单元， 当axis的值为1的时候，将会以行作为查找单元。
sum = [3.01513877 2.05723101]
min = [0.27147445 0.40822491 0.73171587 0.27361339]
max = [0.89280045 0.78042731]
# 求矩阵中最小元素和最大元素的索引
import numpy as np
A = np.arange(2,14).reshape((3,4))
# array([[ 2, 3, 4, 5]
# [ 6, 7, 8, 9]
# [10,11,12,13]])
print(np.argmin(A))
print(np.argmax(A))
0
11
# 整个矩阵的均值
print(np.mean(A)) # 7.5 或写成print(A.mean())
print(np.average(A)) # 7.5
7.5
7.5
# cumsum函数
print(np.cumsum(A))
#在cumsum()函数中：生成的每一项矩阵元素均是从原矩阵首项累加到对应项的元素之和。
[ 2 5 9 14 20 27 35 44 54 65 77 90]
# 累差运算函数
print(np.diff(A))
# 该函数计算的便是每一行中后一项与前一项之差。
[[1 1 1]
[1 1 1]
[1 1 1]]
# nonzero()函数
print(np.nonzero(A))
# 将所有非零元素的行与列坐标分割开，重构成两个分别关于行和列的矩阵。
(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))
# 针对行的排序
import numpy as np
A = np.arange(14,2, -1).reshape((3,4))
# array([[14, 13, 12, 11],
# [10, 9, 8, 7],
# [ 6, 5, 4, 3]])
print(np.sort(A))
[[11 12 13 14]
[ 7 8 9 10]
[ 3 4 5 6]]
# 矩阵的转置
print(np.transpose(A))
print(A.T) # 两种方法都可以
[[14 10 6]
[13 9 5]
[12 8 4]
[11 7 3]]
[[14 10 6]
[13 9 5]
[12 8 4]
[11 7 3]]
# clip()函数
print(np.clip(A,5,9)) # clip(Array,Array_min,Array_max)
# Array指的是将要被执行用的矩阵，而后面的最小值最大值则用于让函数判断矩阵中元素是否有比最小值小的或者比最大值大的元素，并将这些指定的元素转换为最小值或者最大值。
[[9 9 9 9]
[9 9 8 7]
[6 5 5 5]]
2.3 Numpy索引
- 一维索引
import numpy as np
A = np.arange(3,15)
# array([3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
print('第四个元素是：',A[3]) #第四个元素
A = np.arange(3,15).reshape((3,4))
"""
array([[ 3, 4, 5, 6]
[ 7, 8, 9, 10]
[11, 12, 13, 14]])
"""
print('第三行是：',A[2]) # 第三行
第四个元素是： 6
第三行是： [11 12 13 14]
- 二维索引
# 二维矩阵中的单个元素
print(A[1][1])
print(A[1, 1]) # 两种都可以
print(A[1, 1:3])
# 对第二行中第2到第4列元素进行切片输出（不包含第4列）
8
8
[8 9]
# 逐行打印
i=1
for row in A:
print("第%d行：" %(i))
print(row)
i+=1
# 逐列打印
j = 1
for column in A.T:
print("第%d列：" %(j))
print(column)
j += 1
# 逐元素打印
print(A.flatten())
#flatten是一个展开性质的函数，将多维的矩阵进行展开成1行的数列。而flat是一个迭代器，本身是一个object属性。
for item in A.flat:
print(item)
第1行：
[3 4 5 6]
第2行：
[ 7 8 9 10]
第3行：
[11 12 13 14]
第1列：
[ 3 7 11]
第2列：
[ 4 8 12]
第3列：
[ 5 9 13]
第4列：
[ 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
2.4 Numpy array合并
- np.vstack()
vertical stack本身属于一种上下合并，即对括号中的两个整体进行对应操作。
import numpy as np
A = np.array([1,1,1])
B = np.array([2,2,2])
print(np.vstack((A,B))) # vertical stack
C = np.vstack((A,B))
print(A.shape,C.shape)
[[1 1 1]
[2 2 2]]
(3,) (2, 3)
- np.hstack()
左右合并
D = np.hstack((A,B)) # horizontal stack
print(D)
# [1,1,1,2,2,2]
print(A.shape,D.shape)
# (3,) (6,)
[1 1 1 2 2 2]
(3,) (6,)
- np.newaxis()
解决数列（非矩阵属性）的转置问题
print(A[np.newaxis,:])
# [[1 1 1]]
print(A[np.newaxis,:].shape)
# (1,3)
print(A[:,np.newaxis])
"""
[[1]
[1]
[1]]
"""
print(A[:,np.newaxis].shape)
# (3,1)
[[1 1 1]]
(1, 3)
[[1]
[1]
[1]]
(3, 1)
综合上述
import numpy as np
A = np.array([1,1,1])[:,np.newaxis]
B = np.array([2,2,2])[:,np.newaxis]
C = np.vstack((A,B)) # vertical stack
D = np.hstack((A,B)) # horizontal stack
print(D)
[[1 2]
[1 2]
[1 2]]
- np.concatenate()
当你的合并操作需要针对多个矩阵或序列时，借助concatenate函数可能会让你使用起来比前述的函数更加方便。axis参数很好的控制了矩阵的纵向或是横向打印，相比较vstack和hstack函数显得更加方便。
C = np.concatenate((A,B,B,A),axis=0)
print(C)
D = np.concatenate((A,B,B,A),axis=1)
print(D)
[[1]
[1]
[1]
[2]
[2]
[2]
[2]
[2]
[2]
[1]
[1]
[1]]
[[1 2 2 1]
[1 2 2 1]
[1 2 2 1]]
2.5 Numpy array 分割
- 纵向分割
import numpy as np
A = np.arange(12).reshape((3, 4))
print(A)
print(np.split(A, 2, axis=1)) # 只能等量分割，这里不能是3
[[ 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]])]
- 横向分割
print(np.split(A, 3, axis=0))
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
2.6 Numpy copy & deep copy
= 的赋值方式会带有关联性
import numpy as np
a = np.arange(4)
# array([0, 1, 2, 3])
b = a
c = a
d = b
# 改变a，bcd也会改变，改变b，acd也会改变
a[0] = 11
print(a,b,c,d)
d[1:3] = [22, 33]
print(a,b,c,d)
[11 1 2 3] [11 1 2 3] [11 1 2 3] [11 1 2 3]
[11 22 33 3] [11 22 33 3] [11 22 33 3] [11 22 33 3]
copy() 的赋值方式没有关联性
b = a.copy() # deep copy
a[3] = 44
print(a)
print(b)
[11 22 33 44]
[11 22 33 3]
3、Pandas学习
3.1 Pandas的基本介绍
-
Numpy 和 Pandas 有什么不同
如果用 python 的列表和字典来作比较, 那么可以说 Numpy 是列表形式的，没有数值标签，而 Pandas 就是字典形式。Pandas是基于Numpy构建的，让Numpy为中心的应用变得更加简单。 -
Series
Series的字符串表现形式为：索引在左边，值在右边。没有为数据指定索引,会自动创建一个0到N-1（N为长度）的整数型索引。
import pandas as pd
import numpy as np
s = pd.Series([1,3,6,np.nan,44,1]) #NAN默认为0.0
print(s)
0 1.0
1 3.0
2 6.0
3 NaN
4 44.0
5 1.0
dtype: float64
- DataFrame
DataFrame是一个表格型的数据结构，它包含有一组有序的列，每列可以是不同的值类型（数值，字符串，布尔值等）。DataFrame既有行索引也有列索引， 它可以被看做由Series组成的大字典。
dates = pd.date_range('20210101',periods=6)
df = pd.DataFrame(np.random.randn(6,4),index=dates,columns=['a','b','c','d'])
# index行索引，columns列索引
print(df)
a b c d
2021-01-01 -0.050252 -0.850174 1.296784 0.075045
2021-01-02 0.974439 -1.073602 0.416592 -0.440310
2021-01-03 -0.291970 1.205450 0.529891 -0.510023
2021-01-04 -0.068416 1.269137 -0.046621 -0.965386
2021-01-05 -0.486032 -0.468255 -0.622954 0.847579
2021-01-06 1.297612 -1.012137 -1.394533 -0.891579
- DataFrame 的一些简单运用
#根据每一个不同的索引来挑选数据
print(df['b'])
print("-----------------------------------------")
# 创建一组没有给定行标签和列标签的数据 df1——默认行列标签从0开始
df1 = pd.DataFrame(np.arange(12).reshape((3,4)))
print(df1)
print("-----------------------------------------")
# 这种生成方法能对每一列的数据进行特殊对待.
df2 = pd.DataFrame({'A' : 1.,
'B' : pd.Timestamp('20130102'),
'C' : pd.Series(1,index=list(range(4)),dtype='float32'),
'D' : np.array([3] * 4,dtype='int32'),
'E' : pd.Categorical(["test","train","test","train"]),
'F' : 'foo'})
print(df2)
# 查看数据类型
print('数据类型：',df2.dtypes)
# 查看列的序号
print('列的序号：',df2.index)
# 查看数据名称
print('数据名称：',df2.columns)
# 查看数据的值
print('数据的值：\n',df2.values)
# 查看数据的总结
print('数据的总结：\n',df2.describe())
# 翻转数据
print('翻转数据：\n',df2.T)
# 对数据的行标签排序并输出
print('对数据的行标签排序并输出:\n',df2.sort_index(axis=1, ascending=False))
# 对数据的值排序并输出
print('对数据的值排序并输出:\n',df2.sort_values(by='B'))
2021-01-01 -0.850174
2021-01-02 -1.073602
2021-01-03 1.205450
2021-01-04 1.269137
2021-01-05 -0.468255
2021-01-06 -1.012137
Freq: D, Name: b, dtype: float64
-----------------------------------------
0 1 2 3
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
-----------------------------------------
A B C D E F
0 1.0 2013-01-02 1.0 3 test foo
1 1.0 2013-01-02 1.0 3 train foo
2 1.0 2013-01-02 1.0 3 test foo
3 1.0 2013-01-02 1.0 3 train foo
数据类型： A float64
B datetime64[ns]
C float32
D int32
E category
F object
dtype: object
列的序号： Int64Index([0, 1, 2, 3], dtype='int64')
数据名称： Index(['A', 'B', 'C', 'D', 'E', 'F'], dtype='object')
数据的值：
[[1.0 Timestamp('2013-01-02 00:00:00') 1.0 3 'test' 'foo']
[1.0 Timestamp('2013-01-02 00:00:00') 1.0 3 'train' 'foo']
[1.0 Timestamp('2013-01-02 00:00:00') 1.0 3 'test' 'foo']
[1.0 Timestamp('2013-01-02 00:00:00') 1.0 3 'train' 'foo']]
数据的总结：
A C D
count 4.0 4.0 4.0
mean 1.0 1.0 3.0
std 0.0 0.0 0.0
min 1.0 1.0 3.0
25% 1.0 1.0 3.0
50% 1.0 1.0 3.0
75% 1.0 1.0 3.0
max 1.0 1.0 3.0
翻转数据：
0 1 2 \
A 1 1 1
B 2013-01-02 00:00:00 2013-01-02 00:00:00 2013-01-02 00:00:00
C 1 1 1
D 3 3 3
E test train test
F foo foo foo
3
A 1
B 2013-01-02 00:00:00
C 1
D 3
E train
F foo
对数据的行标签排序并输出:
F E D C B A
0 foo test 3 1.0 2013-01-02 1.0
1 foo train 3 1.0 2013-01-02 1.0
2 foo test 3 1.0 2013-01-02 1.0
3 foo train 3 1.0 2013-01-02 1.0
对数据的值排序并输出:
A B C D E F
0 1.0 2013-01-02 1.0 3 test foo
1 1.0 2013-01-02 1.0 3 train foo
2 1.0 2013-01-02 1.0 3 test foo
3 1.0 2013-01-02 1.0 3 train foo
3.2 Pandas 选择数据
tips：关于from future import print_function
在开头加上from future import print_function这句之后，即使在python2.X，使用print就得像python3.X那样加括号使用。(python2.X中print不需要括号，而在python3.X中则需要。) 如果某个版本中出现了某个新的功能特性，而且这个特性和当前版本中使用的不兼容，也就是它在该版本中不是语言标准，那么我如果想要使用的话就需要从future模块导入。
–其他例子：
- from future import division ，
- from future import absolute_import ，
- from future import with_statement 。等等
加上这些，如果你的python版本是python2.X，你也得按照python3.X那样使用这些函数。
from __future__ import print_function
import pandas as pd
import numpy as np
# 建立一个 6X4 的矩阵数据
dates = pd.date_range('20130101', periods=6)
df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=['A', 'B', 'C', 'D'])
print("1.常规情况-----------------------------------------------------------------")
# 1.选取DataFrame中的数据
print(df['A'],"\n", df.A)
# 选择跨越多行或多列:
print(df[0:3], "\n", df['20130102':'20130104'])
print("\n2.loc（location）：根据index来索引-----------------------------------------")
# 2.通过标签名字选择某一行数据:loc
print(df.loc['20130102'])
# 通过选择某行或者所有行（:代表所有行）然后选其中某一列或几列数据。
print(df.loc[:,['A','B']])
print(df.loc['20130102', ['A','B']])
print("\n3.iloc（integer location）：根据行号来索引---------------------------------")
# 3.通过位置选择在不同情况下所需要的数据:iloc
print(df.iloc[3])
print(df.iloc[3, 1])
print(df.iloc[3:5,0:2])
print(df.iloc[[1,2,4],[0,2]])
print("\n4.ix：混合loc和iloc，该方法pandas更新后已经被去除--------------------------")
# 4.根据混合的这两种: ix
# print(df.ix[:3,['A','C']]) # 选择'A'和'C'的两列，并选择前三行的数据
# pandas的1.0.0版本开始，移除了Series.ix and DataFrame.ix 方法，只能用loc或者iloc代替
print(df.iloc[:3,[0,1]])
print("\n5.通过判断的筛选-----------------------------------------------------------")
# 5.通过判断的筛选
print(df[df.A > 0])
1.常规情况-----------------------------------------------------------------
2013-01-01 -0.436329
2013-01-02 0.509224
2013-01-03 0.616790
2013-01-04 0.136219
2013-01-05 0.266872
2013-01-06 -0.045377
Freq: D, Name: A, dtype: float64
2013-01-01 -0.436329
2013-01-02 0.509224
2013-01-03 0.616790
2013-01-04 0.136219
2013-01-05 0.266872
2013-01-06 -0.045377
Freq: D, Name: A, dtype: float64
A B C D
2013-01-01 -0.436329 1.390141 0.290399 0.133450
2013-01-02 0.509224 0.931329 0.740358 -0.251117
2013-01-03 0.616790 1.032171 -0.515533 0.193130
A B C D
2013-01-02 0.509224 0.931329 0.740358 -0.251117
2013-01-03 0.616790 1.032171 -0.515533 0.193130
2013-01-04 0.136219 -1.398217 0.161431 0.403073
2.loc（location）：根据index来索引-----------------------------------------
A 0.509224
B 0.931329
C 0.740358
D -0.251117
Name: 2013-01-02 00:00:00, dtype: float64
A B
2013-01-01 -0.436329 1.390141
2013-01-02 0.509224 0.931329
2013-01-03 0.616790 1.032171
2013-01-04 0.136219 -1.398217
2013-01-05 0.266872 0.816773
2013-01-06 -0.045377 -0.465731
A 0.509224
B 0.931329
Name: 2013-01-02 00:00:00, dtype: float64
3.iloc（integer location）：根据行号来索引---------------------------------
A 0.136219
B -1.398217
C 0.161431
D 0.403073
Name: 2013-01-04 00:00:00, dtype: float64
-1.3982166428389224
A B
2013-01-04 0.136219 -1.398217
2013-01-05 0.266872 0.816773
A C
2013-01-02 0.509224 0.740358
2013-01-03 0.616790 -0.515533
2013-01-05 0.266872 -2.051878
4.ix：混合loc和iloc，该方法pandas更新后已经被去除--------------------------
A B
2013-01-01 -0.436329 1.390141
2013-01-02 0.509224 0.931329
2013-01-03 0.616790 1.032171
5.通过判断的筛选-----------------------------------------------------------
A B C D
2013-01-02 0.509224 0.931329 0.740358 -0.251117
2013-01-03 0.616790 1.032171 -0.515533 0.193130
2013-01-04 0.136219 -1.398217 0.161431 0.403073
2013-01-05 0.266872 0.816773 -2.051878 0.457645
3.3 Pandas 设置值
from __future__ import print_function
import pandas as pd
import numpy as np
# 创建数据：6*4的矩阵
dates = pd.date_range('20130101', periods=6)
df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=['A', 'B', 'C', 'D'])
# 根据位置设置值 ：loc 和 iloc
df.iloc[2,2] = 1111 # 第三行第三个值为1111
df.loc['2013-01-03', 'D'] = 2222
# 根据条件设置值
df.A[df.A>0] = 0
# 按行或列设置值
df['F'] = np.nan
# 添加数据（但长度必须对齐）
df['G'] = pd.Series([1,2,3,4,5,6], index=pd.date_range('20130101', periods=6))
print(df)
A B C D F G
2013-01-01 0.000000 -0.465944 -0.953606 1.103133 NaN 1
2013-01-02 -0.023958 -0.203823 3.042825 -0.214293 NaN 2
2013-01-03 -1.505009 0.650141 1111.000000 2222.000000 NaN 3
2013-01-04 0.000000 -0.144969 0.306719 -1.088664 NaN 4
2013-01-05 -0.931635 0.662629 0.211286 0.413733 NaN 5
2013-01-06 0.000000 0.077605 -0.718108 -0.067400 NaN 6
3.4 处理丢失数据
from __future__ import print_function
import pandas as pd
import numpy as np
# 创建含 NaN 的矩阵
dates = pd.date_range('20130101', periods=6)
df = pd.DataFrame(np.arange(24).reshape((6,4)), index=dates, columns=['A', 'B', 'C', 'D'])
df.iloc[0,1] = np.nan
df.iloc[1,2] = np.nan
print(df)
A B C D
2013-01-01 0 NaN 2.0 3
2013-01-02 4 5.0 NaN 7
2013-01-03 8 9.0 10.0 11
2013-01-04 12 13.0 14.0 15
2013-01-05 16 17.0 18.0 19
2013-01-06 20 21.0 22.0 23
- pd.dropna()——直接去掉有NaN的行或列
print(df.dropna
(axis=0, # 0: 对行进行操作; 1: 对列进行操作
how='any') # how={'any', 'all'}'any': 只要存在 NaN 就 drop 掉; 'all': 必须全部是 NaN 才 drop
)
A B C D
2013-01-03 8 9.0 10.0 11
2013-01-04 12 13.0 14.0 15
2013-01-05 16 17.0 18.0 19
2013-01-06 20 21.0 22.0 23
- pd.fillna()——将NaN用其他值代替
print(df.fillna(value=0))
A B C D
2013-01-01 0 0.0 2.0 3
2013-01-02 4 5.0 0.0 7
2013-01-03 8 9.0 10.0 11
2013-01-04 12 13.0 14.0 15
2013-01-05 16 17.0 18.0 19
2013-01-06 20 21.0 22.0 23
- pd.isnull()——用true/false判断是否缺失
print(pd.isnull(df))
A B C D
2013-01-01 False True False False
2013-01-02 False False True False
2013-01-03 False False False False
2013-01-04 False False False False
2013-01-05 False False False False
2013-01-06 False False False False
3.5 Pandas导入导出
import pandas as pd #加载模块
#读取csv
data = pd.read_csv('student.csv')
#打印出data
print(data)
#将资料存取成pickle
data.to_pickle('student.pickle')
Student ID name age gender
0 1100 Kelly 22 Female
1 1101 Clo 21 Female
2 1102 Tilly 22 Female
3 1103 Tony 24 Male
4 1104 David 20 Male
5 1105 Catty 22 Female
6 1106 M 3 Female
7 1107 N 43 Male
8 1108 A 13 Male
9 1109 S 12 Male
10 1110 David 33 Male
11 1111 Dw 3 Female
12 1112 Q 23 Male
13 1113 W 21 Female
3.6 Pandas合并concat
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'])
#concat纵向合并
res = pd.concat([df1, df2, df3], axis=0,ignore_index=True) # ignore_index:合并后重置 index
#打印结果
print(res)
a b c d
0 0.0 0.0 0.0 0.0
1 0.0 0.0 0.0 0.0
2 0.0 0.0 0.0 0.0
3 1.0 1.0 1.0 1.0
4 1.0 1.0 1.0 1.0
5 1.0 1.0 1.0 1.0
6 2.0 2.0 2.0 2.0
7 2.0 2.0 2.0 2.0
8 2.0 2.0 2.0 2.0
- join：合并方式有两种
- join=‘outer’：依照column来做纵向合并，有相同的column上下合并在一起，其他独自的column个自成列，原本没有值的位置皆以NaN填充。
- join=‘inner’：依照column来做纵向合并，只有相同的column合并在一起，其他的会被抛弃。
- 未设定任何参数时，函数默认join=‘outer’。
- 记忆方法：inner是取交集，outer取并集。
# join, ('inner', 'outer')
df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'], index=[1,2,3])
df2 = pd.DataFrame(np.ones((3,4))*1, columns=['b','c','d', 'e'], index=[2,3,4])
res1 = pd.concat([df1, df2], axis=1, join='outer')
res2 = pd.concat([df1, df2], axis=1, join='inner')
print("outer:\n",res1)
print("inner:\n",res2)
outer:
a b c d b c d e
1 0.0 0.0 0.0 0.0 NaN NaN NaN NaN
2 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0
3 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0
4 NaN NaN NaN NaN 1.0 1.0 1.0 1.0
inner:
a b c d b c d e
2 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0
3 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0
- join_axes:依照 axes 合并
# join_axes
# res = pd.concat([df1, df2], axis=1, join_axes=[df1.index])
# 新版本pandas已经删除了join_axes,可以用merge（下面有）
- append:添加数据
append只有纵向合并，没有横向合并。
# append
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))*1, columns=['b','c','d', 'e'], index=[2,3,4])
s1 = pd.Series([1,2,3,4], index=['a','b','c','d'])
#将df2合并到df1的下面，以及重置index，并打印出结果
res = df1.append(df2, ignore_index=True)
print(res)
#合并多个df，将df2与df3合并至df1的下面，以及重置index，并打印出结果
res = df1.append([df2, df3])
print(res)
#合并series，将s1合并至df1，以及重置index，并打印出结果
res = df1.append(s1, ignore_index=True)
print(res)
a b c d
0 0.0 0.0 0.0 0.0
1 0.0 0.0 0.0 0.0
2 0.0 0.0 0.0 0.0
3 1.0 1.0 1.0 1.0
4 1.0 1.0 1.0 1.0
5 1.0 1.0 1.0 1.0
a b c d e
0 0.0 0.0 0.0 0.0 NaN
1 0.0 0.0 0.0 0.0 NaN
2 0.0 0.0 0.0 0.0 NaN
0 1.0 1.0 1.0 1.0 NaN
1 1.0 1.0 1.0 1.0 NaN
2 1.0 1.0 1.0 1.0 NaN
2 NaN 1.0 1.0 1.0 1.0
3 NaN 1.0 1.0 1.0 1.0
4 NaN 1.0 1.0 1.0 1.0
a b c d
0 0.0 0.0 0.0 0.0
1 0.0 0.0 0.0 0.0
2 0.0 0.0 0.0 0.0
3 1.0 2.0 3.0 4.0
3.7 Pandas合并merge
pandas中的merge和concat类似,但主要是用于两组有key column的数据,统一索引的数据. 通常也被用在Database的处理当中.
- 依据一组key合并
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:\n',left)
print('right:\n',right)
#依据key column合并，并打印出
res = pd.merge(left, right, on='key')
print(res)
left:
key A B
0 K0 A0 B0
1 K1 A1 B1
2 K2 A2 B2
3 K3 A3 B3
right:
key C D
0 K0 C0 D0
1 K1 C1 D1
2 K2 C2 D2
3 K3 C3 D3
key A B C D
0 K0 A0 B0 C0 D0
1 K1 A1 B1 C1 D1
2 K2 A2 B2 C2 D2
3 K3 A3 B3 C3 D3
- 依据俩组key合并
合并时有4种方法how = [‘left’, ‘right’, ‘outer’, ‘inner’]，预设值how=‘inner’。
import pandas as pd
#定义资料集并打印出
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:\n',left)
print('right:\n',right)
#依据key1与key2 columns进行合并，并打印出四种结果['left', 'right', 'outer', 'inner']
res = pd.merge(left, right, on=['key1', 'key2'], how='inner')
print('inner:\n',res) # 交集
res = pd.merge(left, right, on=['key1', 'key2'], how='outer')
print('outer:\n',res) # 并集，并用NaN填充
res = pd.merge(left, right, on=['key1', 'key2'], how='left')
print('left:\n',res) # 左侧DataFrame取全部数据，右侧DataFrame匹配左侧DataFrame。
res = pd.merge(left, right, on=['key1', 'key2'], how='right')
print('right:\n',res)
left:
key1 key2 A B
0 K0 K0 A0 B0
1 K0 K1 A1 B1
2 K1 K0 A2 B2
3 K2 K1 A3 B3
right:
key1 key2 C D
0 K0 K0 C0 D0
1 K1 K0 C1 D1
2 K1 K0 C2 D2
3 K2 K0 C3 D3
inner:
key1 key2 A B C D
0 K0 K0 A0 B0 C0 D0
1 K1 K0 A2 B2 C1 D1
2 K1 K0 A2 B2 C2 D2
outer:
key1 key2 A B C D
0 K0 K0 A0 B0 C0 D0
1 K0 K1 A1 B1 NaN NaN
2 K1 K0 A2 B2 C1 D1
3 K1 K0 A2 B2 C2 D2
4 K2 K1 A3 B3 NaN NaN
5 K2 K0 NaN NaN C3 D3
left:
key1 key2 A B C D
0 K0 K0 A0 B0 C0 D0
1 K0 K1 A1 B1 NaN NaN
2 K1 K0 A2 B2 C1 D1
3 K1 K0 A2 B2 C2 D2
4 K2 K1 A3 B3 NaN NaN
right:
key1 key2 A B C D
0 K0 K0 A0 B0 C0 D0
1 K1 K0 A2 B2 C1 D1
2 K1 K0 A2 B2 C2 D2
3 K2 K0 NaN NaN C3 D3
- Indicator
indicator=True会将合并的记录放在新的一列。
import pandas as pd
#定义资料集并打印出
df1 = pd.DataFrame({'col1':[0,1], 'col_left':['a','b']})
df2 = pd.DataFrame({'col1':[1,2,2],'col_right':[2,2,2]})
print(df1)
print(df2)
# 依据col1进行合并，并启用indicator=True，最后打印出
res = pd.merge(df1, df2, on='col1', how='outer', indicator=True)
print(res)
# 自定indicator column的名称，并打印出
res = pd.merge(df1, df2, on='col1', how='outer', indicator='indicator_column')
print(res)
col1 col_left
0 0 a
1 1 b
col1 col_right
0 1 2
1 2 2
2 2 2
col1 col_left col_right _merge
0 0 a NaN left_only
1 1 b 2.0 both
2 2 NaN 2.0 right_only
3 2 NaN 2.0 right_only
col1 col_left col_right indicator_column
0 0 a NaN left_only
1 1 b 2.0 both
2 2 NaN 2.0 right_only
3 2 NaN 2.0 right_only
- 依据index合并——left_index=True, right_index=True
import pandas as pd
#定义资料集并打印出
left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
'B': ['B0', 'B1', 'B2']},
index=['K0', 'K1', 'K2'])
right = pd.DataFrame({'C': ['C0', 'C2', 'C3'],
'D': ['D0', 'D2', 'D3']},
index=['K0', 'K2', 'K3'])
print(left)
print(right)
#依据左右资料集的index进行合并，how='outer',并打印出
res = pd.merge(left, right, left_index=True, right_index=True, how='outer')
print(res)
#依据左右资料集的index进行合并，how='inner',并打印出
res = pd.merge(left, right, left_index=True, right_index=True, how='inner')
print(res)
A B
K0 A0 B0
K1 A1 B1
K2 A2 B2
C D
K0 C0 D0
K2 C2 D2
K3 C3 D3
A B C D
K0 A0 B0 C0 D0
K1 A1 B1 NaN NaN
K2 A2 B2 C2 D2
K3 NaN NaN C3 D3
A B C D
K0 A0 B0 C0 D0
K2 A2 B2 C2 D2
- 解决overlapping的问题 ——标签重复时给标签加suffixes(后缀)
import pandas as pd
#定义资料集
boys = pd.DataFrame({'k': ['K0', 'K1', 'K2'], 'age': [1, 2, 3]})
girls = pd.DataFrame({'k': ['K0', 'K0', 'K3'], 'age': [4, 5, 6]})
#使用suffixes解决overlapping的问题
res = pd.merge(boys, girls, on='k', suffixes=['_boy', '_girl'], how='inner')
print(res)
k age_boy age_girl
0 K0 1 4
1 K0 1 5
3.8 Pandas plot 出图
- data.plot()——线性图
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# plot data
# 创建一个Series，随机生成1000个数
data = pd.Series(np.random.randn(1000), index=np.arange(1000))
# 为了方便观看效果, 我们累加这个数据
data = data.cumsum()
# pandas 数据可以直接观看其可视化形式
data.plot()
plt.show() #matplotlib 仅仅是用来 show 图片的
- DataFrame可视化
# DataFrame可视化
# 生成一个1000*4 的DataFrame，并对他们累加
data = pd.DataFrame(np.random.randn(1000, 4), index=np.arange(1000), columns=list("ABCD"))
data = data.cumsum()
data.cumsum()
data.plot()
plt.show()
- scatter()——散点图
ax = data.plot.scatter(x='A', y='B', color='DarkBlue', label="Class 1")
# 将之下这个 data 画在上一个 ax 上面
data.plot.scatter(x='A', y='C', color='LightGreen', label='Class 2', ax=ax)
plt.show()
扫一扫
3899
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
