Python学习笔记-数据分析-Pandas02-Dataframe
2024-05-08 08:25:27
Dataframe其实是一个表格型的数据结构，包含一组有序的列，可以理解为一个二维数组。
Dataframe中的数据以一个或多个二维数组块进行存放的，与列表、字典或一维数组的结构不同。其值类型可以是数值、字符串、布尔值等。
一、Pandas-Dataframe的概念和创建
1、Dataframe 简单介绍
Dataframe 是一个带有index（行标签）和columns（列标签）的表格型的数据结构。我的理解就是“带有标签的二维数组”。
import numpy as np
import pandas as pd# 定义一个字典
data = {'名字':['张三','李四','王五'],'年龄':[28,29,30],'性别':['女','男','女']}
# 将字典转换成dataframe
frame = pd.DataFrame(data)
print(frame)
# 类型是pandas.core.frame.DataFrame。
# RangeIndex(start=0, stop=3, step=1)的意思是标签从0开始到3结束（不含3），步长是1.
print(type(frame))
print('---------------------------------------')# frame.index不会直接显示行标签的具体数值，而是RangeIndex(start=0, stop=3, step=1) 形式来展示。
print('这是行标签：\n',frame.index,'\n该数据类型为：',type(frame.index))
print('---------------------------------------')print('这是列标签：\n',frame.columns,'\n该数据类型为：',type(frame.columns))
print('---------------------------------------')# type(frame.values)显示的类型是'numpy.ndarray'，就是一个二维数组。
print('这是值：\n',frame.values,'\n该数据类型为：',type(frame.values))
print('---------------------------------------')
print('显示值是维度：\n',frame.values.ndim)
运行结果如下：
名字 年龄 性别
0 张三 28 女
1 李四 29 男
2 王五 30 女
<class 'pandas.core.frame.DataFrame'>
---------------------------------------
这是行标签：RangeIndex(start=0, stop=3, step=1)
该数据类型为： <class 'pandas.core.indexes.range.RangeIndex'>
---------------------------------------
这是列标签：Index(['名字', '年龄', '性别'], dtype='object')
该数据类型为： <class 'pandas.core.indexes.base.Index'>
---------------------------------------
这是值：[['张三' 28 '女']['李四' 29 '男']['王五' 30 '女']]
该数据类型为： <class 'numpy.ndarray'>
---------------------------------------
显示值是维度：2
2、 Dataframe的创建方法一
通过pandas.Dataframe()，并由数组/list组成的字典进行创建。
通过字典创建的话，Dataframe的columns就是字典key，index为默认数字标签。
字典的值的长度必须保持一致。
# 定义由list组成字典
data1 = {'a':[1,2,3],'b':[3,4,5],'c':[5,6,7]}
# 定义由数组组成字典方式：
#
data2 = {'one':np.random.rand(3),'two':np.random.rand(3)}
print(data1)
print('---------------------')
print(data2)
print('---------------------')# 通过DataFrame方式创建
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)
print(df1)
print('---------------------')
print(df2)
print('---------------------')# 通过index参数改变标签,格式为list。长度必须保持一致
# 如果不一致的话会报错，可以试试下面这两句。
#df3 = pd.DataFrame(data1 ,index = ['W','X','Y','Z'])
#df3 = pd.DataFrame(data1 ,index = ['W','X'])df3 = pd.DataFrame(data1 ,index = ['X','Y','Z'])
print(df3)
print('---------------------')# 通过columns参数可以改变列的顺序，格式为list。
# 注意：说的是改变顺序！！！！！！
# 如果通过columns改变列的顺序，列的数量可以多余或者少于原数据。
# 如果多余的话则产生NaN值# 原来的a b c，通过columns改变顺序 b c a，而且还多了一个d。
df4 = pd.DataFrame(data1, columns = ['b','c','a','d'])
print('注意改变顺序，并且d列全部是NaN：\n', df4)
print('---------------------')
# 原来的a b c，通过columns改变顺序 b c，而且还少了一个。
df5 = pd.DataFrame(data1, columns = ['b','c'])
print('注意改变顺序，并且a列已经不显示了：\n',df5)
print('---------------------')
运行结果如下：
{'a': [1, 2, 3], 'b': [3, 4, 5], 'c': [5, 6, 7]}
---------------------
{'one': array([0.66603783, 0.118737 , 0.5021944 ]), 'two': array([0.56441548, 0.6749825 , 0.17252099])}
---------------------a b c
0 1 3 5
1 2 4 6
2 3 5 7
---------------------one two
0 0.666038 0.564415
1 0.118737 0.674983
2 0.502194 0.172521
---------------------a b c
X 1 3 5
Y 2 4 6
Z 3 5 7
---------------------
注意改变顺序，并且d列全部是NaN：b c a d
0 3 5 1 NaN
1 4 6 2 NaN
2 5 7 3 NaN
---------------------
注意改变顺序，并且a列已经不显示了：b c
0 3 5
1 4 6
2 5 7
---------------------
3、 Dataframe 创建方法二
通过Series组成的字典创建Dataframe，因为Series本身就带index所以在长度不一致的情况下，会生成NaN值。
由Seris组成的字典创建时，Dataframe的columns为字典key，index为Series的标签。
如果Series没有指定标签，则是默认数字标签
# 没有设置index的Series.
data1 = {'A':pd.Series(np.random.rand(2)),'B':pd.Series(np.random.rand(3))}
# 设置了index的Series
data2 = {'C':pd.Series(np.random.rand(2), index = ['a','b']),'D':pd.Series(np.random.rand(3),index = ['a','b','c'])}
# 设置index的时候，index写的都不一致。
data3 = {'E':pd.Series(np.random.rand(2), index = ['a','b']),'F':pd.Series(np.random.rand(3),index = ['x','y','z'])} print('这是没有设置index的：\n', data1)
print('---------------------')
print('这是设置了index的：\n', data2)
print('---------------------')
print('这是设置了index并且都不一致：\n', data3)
print('---------------------')# 由于data1和data2中的one是两行，two是三行，所以在打印的时候，第一列的最后一个值是NaN。
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)# 由于data3在设置的时候index都不一致，所以E列的后三个和F列的前两个全部都是NaN。
df3 = pd.DataFrame(data3)
print('注意index为2的第一个值：\n', df1)
print('---------------------')
print('注意index为c的第一个值：\n', df2)
print('---------------------')
print('注意index都不一致导致的结果：\n', df3)
运行结果如下：
这是没有设置index的：{'A': 0 0.216915
1 0.453241
dtype: float64, 'B': 0 0.223230
1 0.599316
2 0.546660
dtype: float64}
---------------------
这是设置了index的：{'C': a 0.500868
b 0.652345
dtype: float64, 'D': a 0.947658
b 0.272072
c 0.783097
dtype: float64}
---------------------
这是设置了index并且都不一致：{'E': a 0.638341
b 0.982684
dtype: float64, 'F': x 0.742875
y 0.471634
z 0.792849
dtype: float64}
---------------------
注意index为2的第一个值：A B
0 0.216915 0.223230
1 0.453241 0.599316
2 NaN 0.546660
---------------------
注意index为c的第一个值：C D
a 0.500868 0.947658
b 0.652345 0.272072
c NaN 0.783097
---------------------
注意index都不一致导致的结果：E F
a 0.638341 NaN
b 0.982684 NaN
x NaN 0.742875
y NaN 0.471634
z NaN 0.792849
4、Dataframe 创建方法三
通过二维数组直接创建Dataframe。(这个方法是最常用的，尤其是在学习其他工具包的时候)。
通过二维数组创建的话如果不指定index和columns，两者均返回默认数字格式。因为数组本身是不带标签。
# index和colunms指定长度与原数组保持一致
ar = np.random.rand(9).reshape(3,3)
print(ar)
print('---------------------')
df1 = pd.DataFrame(ar)df2 = pd.DataFrame(ar, index = ['a', 'b', 'c'], columns = ['x','y','z']) # 可以尝试一下index或columns长度不等于已有数组的情况
#df3 = pd.DataFrame(ar, index = ['a','b','c'], colums = ['w','x','y','z'])
print('没有设置index和columns的情况：\n', df1)
print('---------------------')
print('设置了index和columns的情况：\n', df2)# 如果index或columns长度不等于已有数组的话就会报错。
#print(df3)
运行结果如下：
[[0.73783499 0.72734161 0.57665585][0.60491658 0.83388939 0.03438341][0.22260236 0.91287993 0.94238993]]
---------------------
没有设置index和columns的情况：0 1 2
0 0.737835 0.727342 0.576656
1 0.604917 0.833889 0.034383
2 0.222602 0.912880 0.942390
---------------------
设置了index和columns的情况：x y z
a 0.737835 0.727342 0.576656
b 0.604917 0.833889 0.034383
c 0.222602 0.912880 0.942390
5、Dataframe 创建方法四
通过字典组成的列表创建Dataframe。
通过字典组成的列表创建时columns为字典的key，index如果不做指定则为默认数组标签。
columns和index参数分别重新指定相应列及行标签
# 注意：通过字组成的列表创建的话，每个字典就一行！
data = [{'A': 1, 'B': 2}, {'A': 5, 'B': 10, 'C': 20}]
print(data)
print('---------------------')
df1 = pd.DataFrame(data)# 设置了index，将之前的0、1变成了a、b
df2 = pd.DataFrame(data, index = ['a','b'])# 设置了columns为B和C，这样就只显示B列和C列。
df3 = pd.DataFrame(data, columns = ['B','C'])# 设置了columns为X和Y，因为和之前字典列表里没有对应的值，所以都是NaN。
df4 = pd.DataFrame(data, columns = ['X','Y'])
print(df1)
print('---------------------')
print(df2)
print('---------------------')
print(df3)
print('---------------------')
print(df4)
运行结果如下：
[{'A': 1, 'B': 2}, {'A': 5, 'B': 10, 'C': 20}]
---------------------A B C
0 1 2 NaN
1 5 10 20.0
---------------------A B C
a 1 2 NaN
b 5 10 20.0
---------------------B C
0 2 NaN
1 10 20.0
---------------------X Y
0 NaN NaN
1 NaN NaN
6、Dataframe 创建方法五
由字典组成的字典
由字典组成的字典创建的时候columns为字典的key，index为子字典的key
columns参数可以增加和减少现有列，如出现新的列，值为NaN。同样的对于原有字典中的缺失值也是用NaN。
index在这里和之前不同，并不能改变原有index。如果改变了会报错。
data = {'A':{'a':90,'b':89,'c':78},'B':{'a':82,'b':95,'c':92},'C':{'a':78,'b':67}}# 最外层的ABC是columns，而内层的abc是index
df1 = pd.DataFrame(data)
# C列的最后一个值没有定义，这里按缺失值处理为NaN。
print(df1)
print('---------------------')# 修改了columns参数原来是ABC，现场是ACD，由于之前没有D，所以D列都是NaN。
df2 = pd.DataFrame(data, columns = ['A','C','D'])# 改变了index，会报错。
#df3 = pd.DataFrame(data, index = ['a','b','c'])
print(df2)
print('---------------------')
#print(df3)
运行结果如下：
A B C
a 90 82 78.0
b 89 95 67.0
c 78 92 NaN
---------------------A C D
a 90 78.0 NaN
b 89 67.0 NaN
c 78 NaN NaN
---------------------
二、Pandas数据结构Dataframe：索引
Dataframe除了有行索引之外，还有针对列的索引，可理解为由Series组成的字典
选择行可以理解为选择一条数据，而选择列可以理解为选择数据中的某个字段。
1、 索引——行和列的基本选择1
df = pd.DataFrame(np.random.rand(12).reshape(3,4)*100,index = ['x','y','z'],columns = ['a','b','c','d'])
print(df)
print('----------------------------')print('------------------------下面是选择列-------------------------')
# 选择列
# df[]在默认的情况下是选择列的，[]中写列名
# 提示：一般对于数据的colunms都会重新制定，而不会用默认数字列名，这样做是为了以免和index混淆。# 单独选址a列
data1 = df['a']
# 选择a和c列，注意括号的写法。
data2 = df[['a','c']]
# 只选择一列，那么得到的数据是Series。
print(data1,type(data1))
print('----------------------------')
# 选择超过一列的，得到的数据是Dataframe。
print(data2,type(data2))
print('----------------------------')# 对于df[]的特别说明：
# df[]中如果是数字的话，默认是选择行的。
# df[]只能通过切片的方式进行选择，不能写成这样：df[0]会报错。
# df[]也不能通过索引标签名来选择行，这样df['x']写也是会报错的。
# df[]一般用于选择列，[]中写列名
data3 = df[:1]
#data3 = df[0]
#data3 = df['x']
# 通过切片方式选择，得到的数据是Dataframe。
print(data3,type(data3))
print('----------------------------')print('------------------------下面是选择行-------------------------')
# 选择行
# 通过.loc[]来进行行的选择。主要针对index选择行，同时支持指定index，及默认数字index
# 按照index选择行，只选择一行输出Series，选择多行输出Dataframe# 定义个DataFrame并且重新指定了index和columns。
df1 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,index = ['w','x','y','z'],columns = ['a','b','c','d'])
# 定义个DataFrame只是重新指定了columns，index采用默认方式。
df2 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,columns = ['a','b','c','d'])
print(df1)
print(df2)
print('----------------------------')# 对于采用单个标签索引的，其返回的类型是Series。
data3 = df1.loc['x']
data4 = df2.loc[1]
print('显示的是索引index为x的那行数据：\n ', data3)
print('----------------------------')
print('显示的是索引index为x的那行数据：\n ', data4)
print('----------------------------')# 可通过添加多个标签进行索引，但是如果标签不存在的话则会返回NaN。
data5 = df1.loc[['x','y','p']]
# 索引的顺序可以改变。
data6 = df2.loc[[3,2,1]]
print('显示的是索引index为x,y,p的3行数据，并且p为NaN：\n ', data5)
print('----------------------------')
print('显示的是索引index为1,2,3的3行数据，但以倒序方式：\n ', data6)
print('----------------------------')# 可通过切片来进行选择。
# 注意：通过切片方式的话，和之前有所不同，这里通过切片的话是左右都包含的。
data7 = df1.loc['w':'y']
data8 = df2.loc[1:3]
print('通过切片 w:y 进行索引，但是包含y：\n ', data7)
print('----------------------------')
print('通过切片 1:3 进行索引，但是包含3：\n ', data8)
print('----------------------------')
运行结果如下：
a b c d
x 16.529413 77.446515 2.845185 32.619139
y 9.738405 92.827843 10.565866 17.580605
z 61.848882 18.604776 83.232469 0.286444
----------------------------
------------------------下面是选择列-------------------------
x 16.529413
y 9.738405
z 61.848882
Name: a, dtype: float64 <class 'pandas.core.series.Series'>
----------------------------a c
x 16.529413 2.845185
y 9.738405 10.565866
z 61.848882 83.232469 <class 'pandas.core.frame.DataFrame'>
----------------------------a b c d
x 16.529413 77.446515 2.845185 32.619139 <class 'pandas.core.frame.DataFrame'>
----------------------------
------------------------下面是选择行-------------------------a b c d
w 3.949465 57.808299 81.568599 90.020367
x 44.025524 49.056827 16.903893 19.732634
y 16.518031 59.383080 44.054548 76.701956
z 62.897651 8.148093 42.969744 51.938212a b c d
0 18.313573 92.570770 81.582609 8.954539
1 51.608370 98.820635 49.728186 5.505197
2 5.148819 11.046620 60.766402 11.839939
3 3.027838 76.914793 93.634612 86.599101
----------------------------
显示的是索引index为x的那行数据：a 44.025524
b 49.056827
c 16.903893
d 19.732634
Name: x, dtype: float64
----------------------------
显示的是索引index为x的那行数据：a 51.608370
b 98.820635
c 49.728186
d 5.505197
Name: 1, dtype: float64
----------------------------
显示的是索引index为x,y,p的3行数据，并且p为NaN：a b c d
x 44.025524 49.056827 16.903893 19.732634
y 16.518031 59.383080 44.054548 76.701956
p NaN NaN NaN NaN
----------------------------
显示的是索引index为1,2,3的3行数据，但以倒序方式：a b c d
3 3.027838 76.914793 93.634612 86.599101
2 5.148819 11.046620 60.766402 11.839939
1 51.608370 98.820635 49.728186 5.505197
----------------------------
通过切片 w:y 进行索引，但是包含y：a b c d
w 3.949465 57.808299 81.568599 90.020367
x 44.025524 49.056827 16.903893 19.732634
y 16.518031 59.383080 44.054548 76.701956
----------------------------
通过切片 1:3 进行索引，但是包含3：a b c d
1 51.608370 98.820635 49.728186 5.505197
2 5.148819 11.046620 60.766402 11.839939
3 3.027838 76.914793 93.634612 86.599101
----------------------------
2、 索引——行和列的基本选择2
通过.iloc[ ]进行选择是按照index默认数组形式来进行选择。如果index是从0到x，那么可选择的范围是0到x-1。
注意：iloc和loc的不同之处就是不能索引超出数据行数的范围。
df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,index = ['w','x','y','z'],columns = ['a','b','c','d'])
print(df)
print('----------------------------')# 单位置索引
print('通过数字0进行索引，结果是索引为w的这行：\n ', df.iloc[0])
print('----------------------------')
print('通过数字-1进行索引，结果是最后一行：\n ', df.iloc[-1])
print('----------------------------')
# 因为index是0、1、2、3所以如果用4进行索引就超出范围了，会报错！！！
#print(df.iloc[4])
print('----------------------------')# 同样可以进行多位置索引，而且可以改变顺序
print('索引的是0和2这两行：\n ', df.iloc[[0,2]])
print('----------------------------')
print('索引的是1、2、3这三行，但是倒序：\n ', df.iloc[[3,2,1]])
print('----------------------------')# 通过切片进行索引，但是末端不包含。
# 可以调整步长
print('通过切片 1:3 进行索引，但是不包含3：\n ', df.iloc[1:3])
print('----------------------------')
print('通过[::2]调整步长为2，所以显示的是index为w和y的：\n ',df.iloc[::2])
print('----------------------------')
运行结果如下：
a b c d
w 16.308251 32.193411 10.682020 66.561990
x 76.318330 82.174286 11.500258 31.735476
y 69.054571 30.695944 33.227954 65.051369
z 56.541266 53.503445 63.348028 20.387269
----------------------------
通过数字0进行索引，结果是索引为w的这行：a 16.308251
b 32.193411
c 10.682020
d 66.561990
Name: w, dtype: float64
----------------------------
通过数字-1进行索引，结果是最后一行：a 56.541266
b 53.503445
c 63.348028
d 20.387269
Name: z, dtype: float64
----------------------------
----------------------------
索引的是0和2这两行：a b c d
w 16.308251 32.193411 10.682020 66.561990
y 69.054571 30.695944 33.227954 65.051369
----------------------------
索引的是1、2、3这三行，但是倒序：a b c d
z 56.541266 53.503445 63.348028 20.387269
y 69.054571 30.695944 33.227954 65.051369
x 76.318330 82.174286 11.500258 31.735476
----------------------------
通过切片 1:3 进行索引，但是不包含3：a b c d
x 76.318330 82.174286 11.500258 31.735476
y 69.054571 30.695944 33.227954 65.051369
----------------------------
通过[::2]调整步长为2，所以显示的是index为w和y的：a b c d
w 16.308251 32.193411 10.682020 66.561990
y 69.054571 30.695944 33.227954 65.051369
----------------------------
3、布尔型索引
先对数据进行判断，然后将结果反馈。
注意：这里的结果是布尔型的，而不是原来的具体数据。
df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,index = ['w','x','y','z'], columns = ['a','b','c','d'])
print(df)# 对df中所有数据进行判断，小于30的为True， 大于30的为False
d1 = df < 30
print('df中所有小于30的为True， 大于30的为False: \n', d1)
print('类型是： \n', type(d1))
print('----------------------------')
# 可以写成下面这样，但是不建议。
#print(df<33)
#print('----------------------------')# 对于索引的结果是保留所有数据，但只有True显示原数据，而False显示为NaN
print('打印df中所有小于30的数值：\n', df[d1])
print('----------------------------')# 只对a列的数据进行判断，小于30的为True， 大于30的为False
d2 = df['a'] < 30
print('df的a列中所有小于30的为True， 大于30的为False: \n', d2)
print('类型是： \n', type(d2))
# 注意：
# 在打印具体数值的时候，除了a列被判断为True的数值外，还包含其他列的数值，但是能显示多少要看a的True和False
# 如果a列被判断成这样：
# True
# True
# False
# False
# 那么就会打印出第一行和第二行的所有数值。
print('打印df的a列中所有大于30的数值，同时包含其他列： \n', df[d2])
print('----------------------------')# 对a和b列的数据进行判断。小于30的为True， 大于30的为False
d3 = df[['a','b']] < 30
print(d3)
print('----------------------------')
print('类型是： \n', type(d3))
# 对于索引的结果是保留所有数据，但只有True显示原数据，而False显示为NaN
print(df[d3])
print('----------------------------')# 对w和y行的数据进行判断。小于30的为True， 大于30的为False
# 注意对行索引强烈推荐loc。
d4 = df.loc[['w','y']] < 30
print(d4)
print('----------------------------')
print('类型是： \n', type(d4))
# 对于索引的结果是保留所有数据，但只有True显示原数据，而False显示为NaN
print(df[d4])
print('----------------------------')
运行结果如下：
a b c d
w 59.388647 64.555426 11.455674 60.053726
x 81.032029 21.109281 95.797383 36.649651
y 23.975000 28.272660 8.227746 52.409161
z 86.684877 82.081464 32.820752 81.644830
df中所有小于30的为True， 大于30的为False: a b c d
w False False True False
x False True False False
y True True True False
z False False False False
类型是： <class 'pandas.core.frame.DataFrame'>
----------------------------
打印df中所有小于30的数值：a b c d
w NaN NaN 11.455674 NaN
x NaN 21.109281 NaN NaN
y 23.975 28.272660 8.227746 NaN
z NaN NaN NaN NaN
----------------------------
df的a列中所有小于30的为True， 大于30的为False: w False
x False
y True
z False
Name: a, dtype: bool
类型是： <class 'pandas.core.series.Series'>
打印df的a列中所有大于30的数值，同时包含其他列： a b c d
y 23.975 28.27266 8.227746 52.409161
----------------------------a b
w False False
x False True
y True True
z False False
----------------------------
类型是： <class 'pandas.core.frame.DataFrame'>a b c d
w NaN NaN NaN NaN
x NaN 21.109281 NaN NaN
y 23.975 28.272660 NaN NaN
z NaN NaN NaN NaN
----------------------------a b c d
w False False True False
y True True True False
----------------------------
类型是： <class 'pandas.core.frame.DataFrame'>a b c d
w NaN NaN 11.455674 NaN
x NaN NaN NaN NaN
y 23.975 28.27266 8.227746 NaN
z NaN NaN NaN NaN
----------------------------
4、多重索引
# 同时对行列进行索引
df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100, index = ['w','x','y','z'], columns = ['a','b','c','d'])
print(df)
print('----------------------------')
# 索引的是a列的w,y行数值。
print(df['a'].loc[['w','y']])
print('----------------------------')
# 索引的是b,d列的第一行数据。
print(df[['b','d']].iloc[0])
print('----------------------------')
# 索引的是a,c列的，并且步长为2，也就现实第一行和第三行，即：w和y行。
print(df[['a','c']].iloc[::2])
print('----------------------------')
# 先进行数值判断
d1 = df < 30
# 索引判断结果为True的最后一行数据。
print(df[d1].iloc[-1])
运行结果如下：
a b c d
w 61.143136 98.644562 73.222458 65.967798
x 55.656472 26.541179 97.922311 2.844820
y 25.861951 37.693418 90.527224 62.268418
z 55.496356 87.046990 34.698108 35.320047
----------------------------
w 61.143136
y 25.861951
Name: a, dtype: float64
----------------------------
b 98.644562
d 65.967798
Name: w, dtype: float64
----------------------------a c
w 61.143136 73.222458
y 25.861951 90.527224
----------------------------
a NaN
b NaN
c NaN
d NaN
Name: z, dtype: float64
三、Pandas数据结构Dataframe：基本操作
数据的增、删、查、改、转置、对齐和排序。
1、数据的增加
df1 = pd.DataFrame(np.random.rand(12).reshape(4,3)*100, index = ['w','x','y','z'], columns = ['a','b','c'])
# 增加列数据：
# 通过增加标签d并赋值，直接给df1增加一列。
print('这是df1的原数据： \n', df1)
print('------------------------------')
df1['d'] = 666
print('为df1增加一个d列，并且d列的数值为666 : \n', df1)
print('------------------------------')
# 增加行数据：
# 通过.loc增加标签v并赋值，直接给df2增加一行
df2 = pd.DataFrame(np.random.rand(12).reshape(4,3)*100, index = ['w','x','y','z'], columns = ['a','b','c'])
print('这是df2的原数据： \n', df2)
print('------------------------------')
df2.loc['v'] = 777
print('为df2增加一个v行，并且v列的数值为777 : \n', df2)
print('------------------------------')
运行结果如下：
这是df1的原数据： a b c
w 13.607961 11.789644 80.573955
x 79.016547 43.206527 71.198012
y 46.399979 16.036760 27.952244
z 0.072979 48.862417 59.460745
------------------------------
为df1增加一个d列，并且d列的数值为666 : a b c d
w 13.607961 11.789644 80.573955 666
x 79.016547 43.206527 71.198012 666
y 46.399979 16.036760 27.952244 666
z 0.072979 48.862417 59.460745 666
------------------------------
这是df2的原数据： a b c
w 23.809699 70.783103 70.005223
x 37.995636 2.598020 70.614041
y 93.017185 78.754241 68.526513
z 87.152016 84.958881 41.068248
------------------------------
为df2增加一个v行，并且v列的数值为777 : a b c
w 23.809699 70.783103 70.005223
x 37.995636 2.598020 70.614041
y 93.017185 78.754241 68.526513
z 87.152016 84.958881 41.068248
v 777.000000 777.000000 777.000000
------------------------------
2、数据的删除
通过del删除列数据
通过drop()删除行数据。
df1 = pd.DataFrame(np.random.rand(15).reshape(5,3)*100, index = ['v','w','x','y','z'], columns = ['a','b','c'])
print('这是df1的原数据：\n', df1)
print('----------------------------')
del df1['a']
print('删除a列的数据： \n', df1)
print('----------------------------')# 注意：
# drop()有inplace参数，如果是False的话，删除后生成新的数据，不改变原数据。
# drop()还有个axis参数，如果axis = 1就是删除列了，默认是0为删除行。df2 = pd.DataFrame(np.random.rand(15).reshape(5,3)*100, index = ['v','w','x','y','z'], columns = ['a','b','c'])
print('这是df2的原数据：\n', df2)
print('----------------------------')print('删除了v行的数据，但是生产新数据：\n', df2.drop('v',inplace = False))
print('----------------------------')
print('这是df2的原数据：\n', df2)
print('----------------------------')
print('删除了y z行的数据，而且是直接删除df2中的对应数据，不会生产新数据：\n', df2.drop(['y','z']))
print('----------------------------')
print('删除c列，并且生产新数据：\n', df2.drop('c', axis = 1 , inplace = False))
print('----------------------------')
print('再看一下df2的数据：\n', df2)
运行结果如下：
这是df1的原数据：a b c
v 73.002271 78.957951 80.803951
w 76.713009 87.137031 8.658484
x 5.951961 5.349587 8.354728
y 62.173308 31.925881 32.797608
z 0.419744 93.180697 70.653208
----------------------------
删除a列的数据： b c
v 78.957951 80.803951
w 87.137031 8.658484
x 5.349587 8.354728
y 31.925881 32.797608
z 93.180697 70.653208
----------------------------
这是df2的原数据：a b c
v 26.738101 94.335920 33.378456
w 80.806494 9.031994 8.114267
x 89.415561 35.009167 89.194081
y 15.791499 5.709047 92.207045
z 27.467260 95.621218 86.529156
----------------------------
删除了v行的数据，但是生产新数据：a b c
w 80.806494 9.031994 8.114267
x 89.415561 35.009167 89.194081
y 15.791499 5.709047 92.207045
z 27.467260 95.621218 86.529156
----------------------------
这是df2的原数据：a b c
v 26.738101 94.335920 33.378456
w 80.806494 9.031994 8.114267
x 89.415561 35.009167 89.194081
y 15.791499 5.709047 92.207045
z 27.467260 95.621218 86.529156
----------------------------
删除了y z行的数据，而且是直接删除df2中的对应数据，不会生产新数据：a b c
v 26.738101 94.335920 33.378456
w 80.806494 9.031994 8.114267
x 89.415561 35.009167 89.194081
----------------------------
删除c列，并且生产新数据：a b
v 26.738101 94.335920
w 80.806494 9.031994
x 89.415561 35.009167
y 15.791499 5.709047
z 27.467260 95.621218
----------------------------
再看一下df2的数据：a b c
v 26.738101 94.335920 33.378456
w 80.806494 9.031994 8.114267
x 89.415561 35.009167 89.194081
y 15.791499 5.709047 92.207045
z 27.467260 95.621218 86.529156
3、数据的查看
通过del删除列数据
通过drop()删除行数据。
df4 = pd.DataFrame(np.random.rand(12).reshape(4,3)*100, index = ['w','x','y','z'], columns = ['a','b','c'])
print('这是df4的原数据： \n', df4)
print('------------------------------')
print('查看第一条数据： \n', df4.head(1))
print('------------------------------')
print('查看最后一条数据： \n', df4.tail(1))
print('------------------------------')
运行结果如下：
这是df4的原数据： a b c
w 78.061825 33.610469 80.406705
x 18.384516 32.375096 62.231457
y 42.604421 78.027042 74.034981
z 50.121260 15.022603 79.553115
------------------------------
查看第一条数据： a b c
w 78.061825 33.610469 80.406705
------------------------------
查看最后一条数据： a b c
z 50.12126 15.022603 79.553115
------------------------------
4、数据的修改
df5 = pd.DataFrame(np.random.rand(12).reshape(4,3)*100, index = ['w','x','y','z'], columns = ['a','b','c'])
print('这是df5的原数据： \n', df5)
print('------------------------------')
# 通过标签来直接修改对应列的数值。
df5['a'] = 100
print('修改a列的数据为100: \n', df5)
print('------------------------------')
# 通过.loc[]标签来直接修改对应行的数值。
df5.loc['x'] = 200
print('修改x行的数据为200: \n', df5)
print('------------------------------')
# 通过步长来修改多行和多列
df6 = pd.DataFrame(np.random.rand(12).reshape(4,3)*100, index = ['w','x','y','z'], columns = ['a','b','c'])
# 通过步长来修改多行
print('这是df6的原数据： \n', df6)
print('------------------------------')
df6[::2] = 300
print('因步长为2,所以修改了第一行和第三行 \n', df6)
print('------------------------------')
# 通过步长来修改多列
df6.loc[::3] = 400
print('因步长为3,所以修改了第一行和第四行 \n', df6)
运行结果如下：
这是df5的原数据： a b c
w 95.171941 23.138967 10.513852
x 22.779183 57.291404 72.941294
y 60.463657 86.761426 85.777703
z 4.729425 11.651567 30.952188
------------------------------
修改a列的数据为100: a b c
w 100 23.138967 10.513852
x 100 57.291404 72.941294
y 100 86.761426 85.777703
z 100 11.651567 30.952188
------------------------------
修改x行的数据为200: a b c
w 100 23.138967 10.513852
x 200 200.000000 200.000000
y 100 86.761426 85.777703
z 100 11.651567 30.952188
------------------------------
这是df6的原数据： a b c
w 7.303756 68.492164 62.553303
x 59.328165 45.051745 9.038321
y 79.662464 19.537964 49.114411
z 24.560472 41.807221 41.922071
------------------------------
因步长为2,所以修改了第一行和第三行 a b c
w 300.000000 300.000000 300.000000
x 59.328165 45.051745 9.038321
y 300.000000 300.000000 300.000000
z 24.560472 41.807221 41.922071
------------------------------
因步长为3,所以修改了第一行和第四行 a b c
w 400.000000 400.000000 400.000000
x 59.328165 45.051745 9.038321
y 300.000000 300.000000 300.000000
z 400.000000 400.000000 400.000000
5、数据的转置
通过.T来进行转置，但是有一点需要注意的是转置后行标签和列标签是一起转置的。
df7 = pd.DataFrame(np.random.rand(15).reshape(5,3)*100, index = ['v','w','x','y','z'], columns = ['a','b','c'])
dft = df7.T
print('这是df7的原数据： \n', df7)
print('-------------------------------')
# 注意和原数据标签的比较。
print(dft)
6、数据的对齐
DataFrame的对齐是按照行和列的标签进行。如果有空值出现的话，对应的位置就是NaN。
df8 = pd.DataFrame(np.random.rand(3,3),columns = ['a','b','c'])
df9 = pd.DataFrame(np.random.rand(3,4),columns = ['a','b','c','d'])
print(df8)
print('-------------------------------')
print(df9)
print('-------------------------------')
print('因为df9是3行4列，而df8是3行3列，所以df9的d列对应的是空值，因此d列的结果就是NaN: \n', df8 + df9)# 下面这种情况就是因为两个DataFrame没有对应的列，所结果都是NaN。
df10 = pd.DataFrame(np.random.rand(3,3),columns = ['a','b','c'])
df11 = pd.DataFrame(np.random.rand(3,3),columns = ['d','e','f'])
print(df10+df11)
运行结果如下：
a b c
0 0.022522 0.803143 0.189595
1 0.829138 0.232753 0.294109
2 0.819474 0.458210 0.682677
-------------------------------a b c d
0 0.982251 0.811988 0.979804 0.502364
1 0.096005 0.886700 0.621619 0.731478
2 0.509606 0.191028 0.515665 0.263442
-------------------------------
因为df9是3行4列，而df8是3行3列，所以df9的d列对应的是空值，因此d列的结果就是NaN: a b c d
0 1.004773 1.615131 1.169399 NaN
1 0.925143 1.119453 0.915729 NaN
2 1.329080 0.649238 1.198342 NaNa b c d e f
0 NaN NaN NaN NaN NaN NaN
1 NaN NaN NaN NaN NaN NaN
2 NaN NaN NaN NaN NaN NaN
关于数据排序的说明：
排序可以按值进行排序，也可以按index标签进行排序
7、按值排序 sort_values
# 按值排序 sort_values
# 参数ascending = True是升序，False是降序。默认情况下是升序。
df1 = pd.DataFrame(np.random.rand(12).reshape(3,4)*100,columns = ['a','b','c','d'])
print('df1的原数据： \n', df1)
# 单列排序
print('根据b列进行升序排列 \n', df1.sort_values(['b'], ascending = True)) # 升序
print('根据a列进行降序排列 \n',df1.sort_values(['a'], ascending = False)) # 降序
print('--------------------------------')# 多列排序
df2 = pd.DataFrame({'a':[1,2,4,1,3,2],'b':list(range(6)),'c':list(range(7,1,-1))},index = ['A','B','C','D','E','F'])
print('df2的原数据： \n', df2)
print('--------------------------------')
# 下面的例子是根据a列和c列对df2进行排序，过程是先根据a列排序，然后在a列排好情况下再对c列进行排序！
# 可通过增加index来观察具体的排序规则。并且可以通过单独打印a列排序和c列排序来进一步了解。
# 特别说明的一点是，如果这个例子中a列的数值都不一样，那么在对a列完成排序后，也就没c列什么事了。
print(df2.sort_values(['a','c']))
print('--------------------------------')
print('单独a列排序 \n', df2.sort_values(['a']))
print('--------------------------------')
print('单独c列排序 \n', df2.sort_values(['c']))
运行结果如下：
df1的原数据： a b c d
0 75.377267 3.874008 0.247614 46.687910
1 9.676426 19.937534 40.039791 71.587142
2 57.925129 59.290481 9.049756 72.978410
根据b列进行升序排列 a b c d
0 75.377267 3.874008 0.247614 46.687910
1 9.676426 19.937534 40.039791 71.587142
2 57.925129 59.290481 9.049756 72.978410
根据a列进行降序排列 a b c d
0 75.377267 3.874008 0.247614 46.687910
2 57.925129 59.290481 9.049756 72.978410
1 9.676426 19.937534 40.039791 71.587142
--------------------------------
df2的原数据： a b c
A 1 0 7
B 2 1 6
C 4 2 5
D 1 3 4
E 3 4 3
F 2 5 2
--------------------------------a b c
D 1 3 4
A 1 0 7
F 2 5 2
B 2 1 6
E 3 4 3
C 4 2 5
--------------------------------
单独a列排序 a b c
A 1 0 7
D 1 3 4
B 2 1 6
F 2 5 2
E 3 4 3
C 4 2 5
--------------------------------
单独c列排序 a b c
F 2 5 2
E 3 4 3
D 1 3 4
C 4 2 5
B 2 1 6
A 1 0 7
8、索引排序 sort_index
同样的也有ascending参数，True升序（默认），False降序。
如果index是字母的话，就会按字母表的顺序排列。
df1 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,index = [6,9,3,1],columns = ['a','b','c','d'])
df2 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,index = ['s','b','j','e'],columns = ['a','b','c','d'])
print('df1原数据： \n', df1)
print('--------------------------------')
print('降序排列： \n', df1.sort_index(ascending = False))
print('--------------------------------')
print('升序排列： \n', df1.sort_index())
print('--------------------------------')
print('df2原数据： \n', df2)
print('--------------------------------')
print('注意index的顺序： \n', df2.sort_index())
运行结果如下：
df1原数据： a b c d
6 5.349366 34.248766 0.977359 14.156496
9 37.074186 20.911655 35.958885 57.944170
3 4.202041 23.575644 36.605424 50.151658
1 34.475989 51.305857 70.071629 39.956406
--------------------------------
降序排列： a b c d
9 37.074186 20.911655 35.958885 57.944170
6 5.349366 34.248766 0.977359 14.156496
3 4.202041 23.575644 36.605424 50.151658
1 34.475989 51.305857 70.071629 39.956406
--------------------------------
升序排列： a b c d
1 34.475989 51.305857 70.071629 39.956406
3 4.202041 23.575644 36.605424 50.151658
6 5.349366 34.248766 0.977359 14.156496
9 37.074186 20.911655 35.958885 57.944170
--------------------------------
df2原数据： a b c d
s 66.468590 94.786982 17.743319 84.707571
b 24.638001 70.560761 7.713197 97.554951
j 27.137341 37.556172 45.386298 23.631172
e 56.164969 51.505736 85.710129 31.032745
--------------------------------
注意index的顺序： a b c d
b 24.638001 70.560761 7.713197 97.554951
e 56.164969 51.505736 85.710129 31.032745
j 27.137341 37.556172 45.386298 23.631172
s 66.468590 94.786982 17.743319 84.707571
Python学习笔记-数据分析-Pandas02-Dataframe相关推荐
- Python学习笔记——数据分析之工作环境准备及数据分析建模理论基础
目录 <Linkedln:2016年中国互联网最热职位人才库报告> Python3.x 常用的新特性 字符串编码格式回顾: DIKW 体系 数据建模基础 <Linkedln:2016 ...
- Python学习笔记——数据分析之数据可视化工具实战案例：世界高峰数据可视化
世界高峰数据可视化 (World's Highest Mountains) 参考:https://www.kaggle.com/alex64/d/abcsds/highest-mountains/le ...
- 【Python学习笔记—保姆版】第四章—关于Pandas、数据准备、数据处理、数据分析、数据可视化
第四章 欢迎访问我搞事情的[知乎账号]:Coffee 以及我的[B站漫威剪辑账号]:VideosMan 若我的笔记对你有帮助,请用小小的手指,点一个大大的赞哦. #编译器使用的是sypder,其中&q ...
- python pandas修改列名,Python_Pandas学习笔记02：DataFrame获取列名和修改列名
Python_Pandas学习笔记02:DataFrame获取列名和修改列名 Python_Pandas学习笔记02:DataFrame获取列名和修改列名 一.参考资料 [1].?Pandas获取列名 ...
- 2016April Python学习笔记（pandasecharts）
2016April Python学习笔记 Git学习 git(/ɡɪt/,关于这个音频文件 音频(帮助·信息))是一个分布式版本控制软件,最初由林纳斯·托瓦兹(Linus Torvalds)创作,于2 ...
- 零基础学Python学习笔记
Python学习笔记 代码下载地址 链接:https://pan.baidu.com/s/1yGnpfq4ZHeKpt4V0J_PTSg 提取码:hmzs 1. Python 基础语法 1.1 基本数 ...
- Python学习笔记——Numpy数组的移动滑窗，使用as_strided实现
Python学习笔记--Numpy数组的移动滑窗,使用as_strided实现 `Numpy`中移动滑窗的实现 为何需要移动滑窗 `Numpy`中的移动滑窗 移动滑窗的`as_strided`实现方法 ...
- python学习笔记目录
人生苦短,我学python学习笔记目录: week1 python入门week2 python基础week3 python进阶week4 python模块week5 python高阶week6 数据结 ...
- python基本语法语句-python学习笔记：基本语法
原标题:python学习笔记:基本语法 缩进:必须使用4个空格来表示每级缩进,支持Tab字符 if语句,经常与else, elif(相当于else if) 配合使用. for语句,迭代器,依次处理迭代 ...
最新文章
- gitlab安装各种坑
- JAVA那点破事！并发、IO模型、集合、线程池、死锁、非阻塞、AQS....
- 官宣！清华大学要搬迁！
- python field详解_Django中models Field详解
- 实时语义分割ENet
- 【攻防世界012】gametime
- C#读取与修改XML文档
- laravel 异常捕获_Laravel框架捕获各种类型错误
- 框架详解_Qt开发技术：QtCharts（一）QtCharts基本介绍以及图表框架详解
- mysql中最常用的存储引擎有_mysql常用的存储引擎有哪些
- CCF2015-9-2日期计算
- java vk减号_Vue入门经常使用指令
- 山东理工大学2021年下半年实验室安全考试
- 科幻计算机类小说,短篇科幻小说推荐 | 黄金时代的五部科幻杰作
- Java 实现 POS 打印机无驱打印
- matlab如何找出相似的图,图像相似性搜索的MATLAB实现
- java 实现微信公众号开发服务器认证
- ion-infinite-scroll上拉加载 ion-refresher下拉刷新
- 【毕业设计】深度学习卫星遥感图像检测与识别 -opencv python 目标检测
- Selenium登录126邮箱，定位不到账号输入框解决办法
热门文章
- PHP微信根据订单号查询支付结果,9. PHP接入微信支付订单、退款订单、转款订单的查询...
- bixby服务器没响应,猫盘开启ssh教程（原版系统，听闻一键x3p已经不能用了！）...
- 微信内置浏览器私有接口WeixinJSBridge的常用方法
- matlab中设x=zsin3x,三阶偏导数设e的sin(2x+3y)次方，求Z的三阶偏导数是多少？
- 日渐临近的苹果秋季发布会，iOS 11 GM 固件到底提前泄露了哪些秘密？
- 中医卫统直报、重点专科、绩效考核病案首页字段汇总-标出差异
- excel双条件筛选
- Android常用adb shell命令
- 有没有ai绘画教程？什么软件能实现ai绘画？
- ubuntu安装最新的chrome浏览器