第二章pandas基本数据结构
2.1DataFrame
DataFrame表示的是一个矩阵数据表,它包含已排序的列集合,每一列可以是不同的值类型。DataFrame中的数据被存储在一个以上的数据块中,与索引分开。
2.1.1创建DataFrame
有多种方式创建一个DataFrame,下表为DaFrame类定义:
pd.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)
参数1:data:指定数据ndarray(结构化或同类),Iterable,dict或DataFrame
参数2:index:指定行标签,用于索引。如果没有输入数据的索引信息并且没有提供索引,则默认为RangeIndex。
参数3:columns:指定列标签,用于结果框架的列标签。如果未提供列标签,则默认为RangeIndex(0,1,2,…,n)
参数4:dtype:指定数据类型
参数5:copy:指定是否从输入中复制数据。仅影响DataFrame / 2d ndarray输入
方法1:传递字典创建DataFrame。
正确示例:传递3个字典构造DataFrame。
#方法1:传递3个字典构造DataFrame
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
'year':[2000, 2001, 2002, 2001, 2002, 2003],
'pop':[1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
df = pd.DataFrame(data)
------------------------------------------------------------
state year pop
0 Ohio 2000 1.5
1 Ohio 2001 1.7
2 Ohio 2002 3.6
3 Nevada 2001 2.4
4 Nevada 2002 2.9
5 Nevada 2003 3.2
方法2:传递numpy ndarray构造DataFrame。
正确示例:传递一个2维ndarray数组构造DataFrame。
#方法2:传递一个2维ndarray数组构造DataFrame
df2 = pd.DataFrame(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
columns=['a', 'b', 'c'])
------------------------------------------------------------
a b c
0 1 2 3
1 4 5 6
2 7 8 9
方法3:传递数据类构造DataFrame。
正确示例:使用make_dataclass数据类构造DataFrame。
#方法3:使用make_dataclass数据类构造DataFrame
from dataclasses import make_dataclass
Point = make_dataclass("Point", [("x", int), ("y", int)])
pd.DataFrame([Point(0, 0), Point(0, 3), Point(2, 3)])
------------------------------------------------------------
x y
0 0 0
1 0 3
2 2 3
2.1.2DataFrame索引和切片
不管是索引还是切片其核心目标都是找出符合要求的数据子集,可以理解为在一个网格大矩形中选小矩形。
#初始化数据
df = pd.DataFrame(np.random.randn(25).reshape((5, 5)), columns=list('ABCDE'), index=list('abcde'))
--------------------------------------------------------------------------
A B C D E
a -2.070455 0.007495 -1.422376 0.815679 0.690889
b -1.337253 0.592946 0.161424 0.290307 -1.088162
c 0.043417 -0.737498 1.173350 -0.748822 0.455126
d -0.020499 -0.124754 -1.680849 -0.017379 -1.977535
e 0.118669 -0.293677 -0.407705 -0.857130 1.147254
2.1.2.1按列索引
方法1:df.列名
。
正确示例:传递单个列标签索引一列。
#方法1:传递单个列标签索引一列
df.A
--------------------------------------------------------------------------
0 -2.070455
1 -1.337253
2 0.043417
3 -0.020499
4 0.118669
Name: A, dtype: float64
方法2:df[['列名1','列名2','列名3'....]]
。
正确示例:传递多个列标签索引多列。
#方法2:传递多个列标签索引多列
df[['A', 'B', 'C']]
--------------------------------------------------------------------------
A B C
0 -2.070455 0.007495 -1.422376
1 -1.337253 0.592946 0.161424
2 0.043417 -0.737498 1.173350
3 -0.020499 -0.124754 -1.680849
4 0.118669 -0.293677 -0.407705
方法3:df.iloc[:,列号1:列号2]。
正确示例:传递列号,依据列号索引多列,不包括列号末尾列。
#方法3:传递列号,依据列号索引多列,不包括列号末尾列
df.iloc[:, 1:3]
--------------------------------------------------------------------------
B C
0 0.007495 -1.422376
1 0.592946 0.161424
2 -0.737498 1.173350
3 -0.124754 -1.680849
4 -0.293677 -0.407705
方法4:df.loc[:, 'A' : 'C']。
正确示例:传递标签,依据列标签索引多列,包括标签末尾列。
#方法4:传递标签,依据列标签索引多列,包括标签末尾列
df.loc[:, 'A' : 'C']
--------------------------------------------------------------------------
A B C
0 -2.070455 0.007495 -1.422376
1 -1.337253 0.592946 0.161424
2 0.043417 -0.737498 1.173350
3 -0.020499 -0.124754 -1.680849
4 0.118669 -0.293677 -0.407705
2.1.2.1按行索引
方法1:df.loc[row, :]
或者df.loc['a':'c']
。
正确示例:传递行标签,依据行标签索引多列,包括标签末尾行。
#方法1-1:传递行标签,依据行标签索引多列,包括标签末尾行
df.loc['a':'c',:]
--------------------------------------------------------------------------
A B C D E
a -2.070455 0.007495 -1.422376 0.815679 0.690889
b -1.337253 0.592946 0.161424 0.290307 -1.088162
c 0.043417 -0.737498 1.173350 -0.748822 0.455126
#方法1-2:传递行标签,依据行标签索引多列,包括标签末尾行
df.loc['a':'c']
--------------------------------------------------------------------------
A B C D E
a -2.070455 0.007495 -1.422376 0.815679 0.690889
b -1.337253 0.592946 0.161424 0.290307 -1.088162
c 0.043417 -0.737498 1.173350 -0.748822 0.455126
方法2:df.[列标签][行标签]
或者df.列标签[行标签]
。
正确示例:传递列标签+行标签索引多行。
#方法2-1:传递列标签+行标签索引多行
df.A[['a', 'b', 'c']]
--------------------------------------------------------------------------
a -2.070455
b -1.337253
c 0.043417
Name: A, dtype: float64
#方法2-2:传递列标签+行标签索引多行
df['A'][['a', 'b', 'c']]
--------------------------------------------------------------------------
a -2.070455
b -1.337253
c 0.043417
Name: A, dtype: float64
方法3:df.iloc[行号1 : 行号2,:]。
正确示例:传递行号,按行号进行索引。
#方法3:传递行号,按行号进行索引
df.iloc[1:3, :]
--------------------------------------------------------------------------
A B C D E
b -1.337253 0.592946 0.161424 0.290307 -1.088162
c 0.043417 -0.737498 1.173350 -0.748822 0.455126
2.1.2.3按单元格索引
方法1:df[列标签][行标签]
或者df.列标签[行标签]
。
正确示例:传递一列标签和一行标签,按行列标签索引单元格。
#方法1-1:传递一列标签和一行标签,按行列标签索引单元格
df.A['a']
--------------------------------------------------------------------------
-2.070455
#方法1-2:传递一列标签和一行标签,按行列标签索引单元格
df['A']['a']
--------------------------------------------------------------------------
-2.070455
方法2:df.loc[行标签][列标签]
。
正确示例:传递一行标签和一列标签,依据行列标签索引单元格。
#方法2:传递一行标签和一列标签,依据行列标签索引单元格
df.loc['a']['A']
--------------------------------------------------------------------------
-2.070455
方法3:df.iloc[行号][列号]
。
正确示例:传递一个行号和一个列号,依据行列号索引单元格。
#方法3:传递一个行号和一个列号,依据行列号索引单元格
df.iloc[0][0]
--------------------------------------------------------------------------
-2.070455
方法4:df.at[行标签,列标签]
。
正确示例:传递行标签和列标签索引单值。
#方法4:传递行标签和列标签索引单值
df.at['a', 'A']
--------------------------------------------------------------------------
-2.070455
方法5:df.loc[行标签].at[列标签]
或者df.loc[:,列标签].at[行标签]。
正确示例:传递行、列标签各一个索引单值。
#方法5-1:传递行、列标签各一个索引单值
df.loc['a'].at['A']
--------------------------------------------------------------------------
-2.070455
#方法5-2:传递行、列标签各一个索引单值
df.loc[:,'A'].at['a']
--------------------------------------------------------------------------
-2.070455
方法6:df.iloc[行号].at[列标签]
或者df.iloc[:,列号].at[行标签]
。
正确示例:传达列号+行标签索引单值。
#方法6:传达列号+行标签索引单值
df.iloc[:, 0].at['a']
--------------------------------------------------------------------------
-2.070455
2.1.2.4布尔索引
布尔数组是一种只有True和False组成的数组,这样的数组可以用做筛选器,筛选出布尔数组元素为True位置上的值。
#初始数据集
df = pd.DataFrame(np.random.randn(25).reshape((5, 5)), columns=list('ABCDE'), index=list('abcde'))
------------------------------------------------------------
A B C D E
a 0.747188 0.421967 -0.689784 -1.002356 0.015856
b 1.154583 -0.804672 -0.224397 0.099331 2.408056
c -0.521834 0.150080 0.157463 0.412531 0.865473
d -0.365764 -1.139993 1.523171 0.114032 0.073803
e 1.692965 -0.225460 -0.466945 -1.563331 -0.334051
使用布尔数组进行索引,df[条件]
。
#创建布尔数组
df[df>0]
------------------------------------------------------------
A B C D E
a 0.747188 0.421967 NaN NaN 0.015856
b 1.154583 NaN NaN 0.099331 2.408056
c NaN 0.150080 0.157463 0.412531 0.865473
d NaN NaN 1.523171 0.114032 0.073803
e 1.692965 NaN NaN NaN NaN
#使用布尔数组进行索引
df[df>df.mean()]
------------------------------------------------------------
A B C D E
a 0.747188 0.421967 NaN NaN NaN
b 1.154583 NaN NaN 0.099331 2.408056
c NaN 0.150080 0.157463 0.412531 0.865473
d NaN NaN 1.523171 0.114032 NaN
e 1.692965 -0.225460 NaN NaN NaN
ps1:条件可以是各种各样的,但必须是可以逐元素传递的
2.1.3DataFrame/DataFrame赋值
所有的索引、切片都可以进行=赋值,下面只介绍按行和按列进行赋值,按单元格进行赋值暂不赘述。
#初始化数据
df = pd.DataFrame(np.arange(25).reshape((5, 5)), columns=list('ABCDE'), index=list('abcde'))
------------------------------------------------------------
A B C D E
a 0 1 2 3 4
b 5 6 7 8 9
c 10 11 12 13 14
d 15 16 17 18 19
e 20 21 22 23 24
2.1.3.1 按列赋值
方法1:df.列名=Values
。
正确示例:传递列标签赋值。
#方法1:传递列标签赋值
df.A = 0
------------------------------------------------------------
A B C D E
a 0 1 2 3 4
b 0 6 7 8 9
c 0 11 12 13 14
d 0 16 17 18 19
e 0 21 22 23 24
方法2:df[列名]=colList/colValue
。
正确示例:传递列标签进行赋值。
#方法2:传递列标签进行赋值
df['A'] = [1, 2, 3, 4, 5]
------------------------------------------------------------
A B C D E
a 1 1 2 3 4
b 2 6 7 8 9
c 3 11 12 13 14
d 4 16 17 18 19
e 5 21 22 23 24
方法3:df.loc[:,列名] = Values
正确示例:使用loc方法传递列标签进行赋值。
#方法3:使用loc方法传递列标签进行赋值
df.loc[:, 'A'] = [0, 1, 2, 3, 4]
------------------------------------------------------------
A B C D E
a 0 1 2 3 4
b 1 6 7 8 9
c 2 11 12 13 14
d 3 16 17 18 19
e 4 21 22 23 24
方法4:df.iloc[:,列号] = Values
正确示例:使用iloc方法传递列标签进行赋值。
#方法4:使用iloc方法传递列标签进行赋值
df.iloc[:, 0] = [0, 0, 0, 0, 0]
------------------------------------------------------------
A B C D E
a 0 1 2 3 4
b 0 6 7 8 9
c 0 11 12 13 14
d 0 16 17 18 19
e 0 21 22 23 24
赋值多列:
赋值多列,下面两个例子的赋值结果不同。
对比示例1:0-9数组转换形状为5行2列。
#对比示例1:0-9数组转换形状为5行2列
df.loc[:, ['A', 'C']] = np.arange(10).resh ape((5, 2))
------------------------------------------------------------
A B C D E
a 0 1 1 3 4
b 2 6 3 8 9
c 4 11 5 13 14
d 6 16 7 18 19
e 8 21 9 23 24
对比示例2:0-9数组转换形状为2行5列再进行转置。
#对比示例2:0-9数组转换形状为2行5列再进行转置
df.loc[:, ['A', 'C']] = np.arange(10).reshape((2, 5)).T
------------------------------------------------------------
A B C D E
a 0 1 5 3 4
b 1 6 6 8 9
c 2 11 7 13 14
d 3 16 8 18 19
e 4 21 9 23 24
ps1:如果用一个列表或数组赋值,其长度必须和df的行数相同
ps2:上述赋值方式都是在原视图上操作不会产生新的实例
ps3:多列赋值的时候两者形状必须相等,且是按列直接赋值
2.1.3.2按行赋值
方法1:df.loc[行标签,:]=Values
或者df.loc[行标签]=Values
。
正确示例:使用loc方法传递行标签进行行赋值。
#方法1-1:使用loc方法传递行标签进行行赋值
df.loc['a', :] = 15
------------------------------------------------------------
A B C D E
a 15 15 15 15 15
b 1 6 6 8 9
c 2 11 7 13 14
d 3 16 8 18 19
e 4 21 9 23 24
#方法1-2:使用loc方法传递行标签进行行赋值
df.loc['a'] = 15
------------------------------------------------------------
A B C D E
a 15 15 15 15 15
b 1 6 6 8 9
c 2 11 7 13 14
d 3 16 8 18 19
e 4 21 9 23 24
方法2:df.iloc[行号]=Values
或者df.iloc[行号, :]=Values
。
正确示例:使用iloc方法传递行号进行行赋值。
#方法2-1:使用iloc方法传递行号进行行赋值
df.iloc[0] = 55
------------------------------------------------------------
A B C D E
a 55 55 55 55 55
b 1 6 6 8 9
c 2 11 7 13 14
d 3 16 8 18 19
e 4 21 9 23 24
#方法2-2:使用iloc方法传递行号进行行赋值
df.iloc[0, :] = 55
------------------------------------------------------------
A B C D E
a 55 55 55 55 55
b 1 6 6 8 9
c 2 11 7 13 14
d 3 16 8 18 19
e 4 21 9 23 24
多行赋值
下面两个例子,同样两种赋值方式,其结果是不同的。
对比示例1:0-9数组转换形状为2行5列。
#对比示例1:0-9数组转换形状为2行5列
df.loc[['a', 'b'], :] = np.arange(10).reshape((2, 5))
------------------------------------------------------------
A B C D E
a 0 1 2 3 4
b 5 6 7 8 9
c 2 11 7 13 14
d 3 16 8 18 19
e 4 21 9 23 24
对比示例2:0-9数组转换形状为5行2列再转置。
#对比示例2:0-9数组转换形状为5行2列再转置
df.loc[['a', 'b'], :] = np.arange(10).reshape((5, 2)).T
--------------------------------------------------------------------------
A B C D E
a 0 2 4 6 8
b 1 3 5 7 9
c 2 11 7 13 14
d 3 16 8 18 19
e 4 21 9 23 24
ps1:所有的赋值注意点和列赋值相同
2.1.4DataFrame插入
2.1.4.1插入一列
方法1:df.insert(位置,列名,值)
。
正确示例1:在末尾插入一列。
#方法1-1:在末尾插入一列
df.insert(5, 'F', [1, 2, 3, 4, 5])
------------------------------------------------------------------------------------------------------
A B C D E F
a 0 2 4 6 8 1
b 1 3 5 7 9 2
c 2 11 7 13 14 3
d 3 16 8 18 19 4
e 4 21 9 23 24 5
正确示例2:在中间插入一列。
#方法1-2:在末尾插入一列
df.insert(2, 'F', [10, 11, 12, 13, 14])
------------------------------------------------------------------------------------------------------
A B F C D E
a 0 1 10 2 3 4
b 5 6 11 7 8 9
c 10 11 12 12 13 14
d 15 16 13 17 18 19
e 20 21 14 22 23 24
错误示例1:插入一列已经存在的列。
#方法1错误示例1:如果列已经存在则无法插入
df.insert(6, 'F', [1, 2, 3, 4, 5])
------------------------------------------------------------------------------------------------------
ValueError: cannot insert F, already exists
错误示例2:插入一列,其数据长度错误。
#方法1错误示例2:插入的数据长度错误
df.insert(5, 'F', [1, 2, 3])
------------------------------------------------------------------------------------------------------
ValueError: Length of values (3) does not match length of index (5)
错误示例3:插入一列,其数据位置超出范围。
#方法1错误示例3:插入的数据位置错误
df.insert(10, 'F', [10, 11, 12, 13, 14])
------------------------------------------------------------------------------------------------------
IndexError: index 10 is out of bounds for axis 0 with size 5
ps1:插入一列到中间,位置前的列不会改变,插入位置原本的列会往后延展。
ps2:插入位置范围在于0 <= loc <= len(df.columns)。
方法2:df.loc[:, 列名]=Values
。
正确示例1:使用列名插入一列,该列本身不存在,只会在末尾插入。
#方法2-1:使用列名插入一列
df.loc[:, 'F'] = [10, 10, 10, 10, 10]
------------------------------------------------------------------------------------------------------
A B C D E F
a 0 1 2 3 4 10
b 5 6 7 8 9 10
c 10 11 12 13 14 10
d 15 16 17 18 19 10
e 20 21 22 23 24 10
正确示例2:使用列名插入一列,该列本身存在,则会直接覆盖。
#方法2-2:使用列名插入一列
df.loc[:, 'C'] = [10, 10, 10, 10, 10]
------------------------------------------------------------------------------------------------------
A B C D E F
a 0 1 10 3 4 10
b 5 6 10 8 9 10
c 10 11 10 13 14 10
d 15 16 10 18 19 10
e 20 21 10 23 24 10
ps1:iloc方法和loc方法是一样的使用方式。
ps2:在末尾插入一列和按列赋值有一定的相似之处。
2.1.4.2插入一行
方法1:df.loc[行名称]=Values
。
这个方法相当于赋值了任意一行,包括存在和不存在的。
正确示例1:赋值末尾行,相当于在DataFrame末尾添加一行。
#方法1-1:使用loc方法赋值末尾行
df.loc['f'] = [1, 1, 1, 1, 1]
------------------------------------------------------------------------------------------------------
A B C D E
a 0 1 2 3 4
b 5 6 7 8 9
c 10 11 12 13 14
d 15 16 17 18 19
e 20 21 22 23 24
f 1 1 1 1 1
正确示例2:末尾添加一行并更使用reindex
更改其位置。
#方法1-2:使用loc方法赋值末尾行
df.loc['f'] = [1, 1, 1, 1, 1]
df.reindex(list('fabcde'))
-----------------------------------------------------------------------------------------------------
A B C D E
f 1 1 1 1 1
a 0 1 2 3 4
b 5 6 7 8 9
c 10 11 12 13 14
d 15 16 17 18 19
e 20 21 22 23 24
方法2:df.append(添加对象)
。
正确示例:在末尾添加一行,添加的对象必须具有相同的列标签。
#方法2:使用append方法在末尾添加一行
df.append(pd.Series([1, 1, 1, 1, 1, 1], name='f', index=list('ABCDEF')))
------------------------------------------------------------------------------------------------------
A B C D E F
a 0 1 10 3 4 10
b 5 6 10 8 9 10
c 10 11 10 13 14 10
d 15 16 10 18 19 10
e 20 21 10 23 24 10
f 1 1 1 1 1 1
错误示例:添加的对象没有相同的列标签。
#方法2错误示例:添加的对象没有相同的列标签
df.append(pd.Series([1, 1, 1, 1, 1, 1], name='f'))
-----------------------------------------------------------------------------------------------------
A B C D E F 0 1 2 3 4 5
a 0.0 1.0 10.0 3.0 4.0 10.0 NaN NaN NaN NaN NaN NaN
b 5.0 6.0 10.0 8.0 9.0 10.0 NaN NaN NaN NaN NaN NaN
c 10.0 11.0 10.0 13.0 14.0 10.0 NaN NaN NaN NaN NaN NaN
d 15.0 16.0 10.0 18.0 19.0 10.0 NaN NaN NaN NaN NaN NaN
e 20.0 21.0 10.0 23.0 24.0 10.0 NaN NaN NaN NaN NaN NaN
f NaN NaN NaN NaN NaN NaN 1.0 1.0 1.0 1.0 1.0 1.0
2.1.5DataFrame删除
2.1.5.1删除行或列
方法1:df.drop(列名/行名, axis=1/axis=0)
。
drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors=‘raise’)
参数1:labels:指定要删除的行列标签
参数2:axis:指定要删除行还是列
参数3:index:axis参数的代替方法,
axis=0
和index=labels
等价参数4:columns:axis参数的代替方法,
axis=1
和columns=labels
等价参数5:level:指定要删除的行列层级
参数6:inplace:指定是否在原视图上进行操作
参数7:errors:指定是否忽略错误,可选{‘ignore’, ‘raise’}
返回值:如果
inplace=True
则返回None,否则返回DataFrame实例
正确示例1:删除一行,删除对象要和axis
参数挂钩,axis=0
实际意义是沿着行索引方向,并不能简单理解为行。
#方法1-1:传递行标签删除一行
df.drop('a', axis=0)
-----------------------------------------------------------------------------------------------------
A B C D E
b 5 6 7 8 9
c 10 11 12 13 14
d 15 16 17 18 19
e 20 21 22 23 24
正确示例2:删除一列。
#方法1-2:传递列标签删除一列
df.drop('A', axis=1)
-----------------------------------------------------------------------------------------------------
B C D E
a 1 2 3 4
b 6 7 8 9
c 11 12 13 14
d 16 17 18 19
e 21 22 23 24
错误示例1:axis参数错误,想删除列却传递axis=0
则会引发KeyError。
#方法1错误示例:axis参数错误,想删除列却传递`axis=0`则会引发KeyError
df.drop('A', axis=0)
-----------------------------------------------------------------------------------------------------
KeyError: "['A'] not found in axis"
2.1.6DataFrame的转换
#初始化数据
df = pd.DataFrame(np.arange(25).reshape((5, 5)), columns=list('ABCDE'), index=list('abcde'))
-----------------------------------------------------------------------------------------------------
A B C D E
a 0 1 2 3 4
b 5 6 7 8 9
c 10 11 12 13 14
d 15 16 17 18 19
e 20 21 22 23 24
2.1.6.1转换为ndarray
方法1:.values
属性。
正确示例:调用values属性获取DataFrame的值。
#方法1:使用.values属性
df.values
-----------------------------------------------------------------------------------------------------
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19],
[20, 21, 22, 23, 24]])
对比示例:元素类型不一致,将选择容纳所有类型的dtypes。
#对比示例:元素类型不一致,将选择容纳所有类型的dtypes
df = pd.DataFrame({'age': [ 3, '29'],
'height': [94, 170.5],
'weight': [31, 115]})
df.values
-----------------------------------------------------------------------------------------------------
array([[3, 94.0, 31],
['29', 170.5, 115]], dtype=object)
方法2:to_numpy()
方法。
to_numpy(dtype=None, copy=False, na_value=object)
参数1:dtype:指定元素类型
参数2:copy:布尔型,指定是否创建副本
参数3:na_value:指定缺失值替代值
返回值:ndarray数组
正确示例:
#方法2:使用to_numpy方法将DataFrame转换为ndarray
df.to_numpy()
-----------------------------------------------------------------------------------------------------
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19],
[20, 21, 22, 23, 24]])
ps1:values属性仅返回删除轴标签的DataFrame中的值,建议使用方法2。
ps2:使用values属性时如果dtypes(甚至是数字类型)是混合型的,则将选择容纳所有类型的dtypes。
2.1.6.7转换为字典
方法1:to_dict()
方法。
to_dict(orient=‘dict’, into=<class ‘dict’>)
参数1:orient:字符型,指定字典值的类型,可选{‘dict’,‘list’,‘series’,‘split’,'records,‘index’}
dict:{column-> {index-> value}}这样的字典
list:类似{column-> [values]}的字典
series:类似{column-> Series(values)}的字典
split:类似{‘index’-> [index],‘columns’-> [columns],‘data’-> [values]}的字典
records:类似于[{column-> value},…,{column-> value}]的列表
index:类似{index-> {column-> value}}的字典
参数2:into:未知
返回值:字典,列表或者映射类型
正确示例1:传递参数orient='dict'
或者不传递参数。
#使用to_dict将DataFrame转换为字典方法1,参数:dict
df.to_dict(orient='dict')
-----------------------------------------------------------------------------------------------------
{'A': {'a': 0, 'b': 5, 'c': 10, 'd': 15, 'e': 20},
'B': {'a': 1, 'b': 6, 'c': 11, 'd': 16, 'e': 21},
'C': {'a': 2, 'b': 7, 'c': 12, 'd': 17, 'e': 22},
'D': {'a': 3, 'b': 8, 'c': 13, 'd': 18, 'e': 23},
'E': {'a': 4, 'b': 9, 'c': 14, 'd': 19, 'e': 24}}
#使用to_dict将DataFrame转换为字典方法1,不传递参数
df.to_dict()
-----------------------------------------------------------------------------------------------------
{'A': {'a': 0, 'b': 5, 'c': 10, 'd': 15, 'e': 20},
'B': {'a': 1, 'b': 6, 'c': 11, 'd': 16, 'e': 21},
'C': {'a': 2, 'b': 7, 'c': 12, 'd': 17, 'e': 22},
'D': {'a': 3, 'b': 8, 'c': 13, 'd': 18, 'e': 23},
'E': {'a': 4, 'b': 9, 'c': 14, 'd': 19, 'e': 24}}
正确示例2:传递参数orient='list'
。
#DataFrame转换为字典方法1,参数:list
df.to_dict(orient='list')
-----------------------------------------------------------------------------------------------------
{'A': [0, 5, 10, 15, 20],
'B': [1, 6, 11, 16, 21],
'C': [2, 7, 12, 17, 22],
'D': [3, 8, 13, 18, 23],
'E': [4, 9, 14, 19, 24]}
正确示例3:传递参数orient='series'
。
#DataFrame转换为字典方法1,参数:series
df.to_dict(orient='series')
-----------------------------------------------------------------------------------------------------
{'A': a 0
b 5
c 10
d 15
e 20
Name: A, dtype: int32,
'B': a 1
b 6
c 11
d 16
e 21
Name: B, dtype: int32,
'C': a 2
b 7
c 12
d 17
e 22
Name: C, dtype: int32,
'D': a 3
b 8
c 13
d 18
e 23
Name: D, dtype: int32,
'E': a 4
b 9
c 14
d 19
e 24
Name: E, dtype: int32}
正确示例4:传递参数orient='split'
。
#DataFrame转换为字典方法1,参数:split
df.to_dict(orient='split')
-----------------------------------------------------------------------------------------------------
{'index': ['a', 'b', 'c', 'd', 'e'],
'columns': ['A', 'B', 'C', 'D', 'E'],
'data': [[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9],
[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19],
[20, 21, 22, 23, 24]]}
正确示例5:传递参数orient='records'
。
#DataFrame转换为字典方法1,参数:records
df.to_dict(orient='records')
-----------------------------------------------------------------------------------------------------
[{'A': 0, 'B': 1, 'C': 2, 'D': 3, 'E': 4},
{'A': 5, 'B': 6, 'C': 7, 'D': 8, 'E': 9},
{'A': 10, 'B': 11, 'C': 12, 'D': 13, 'E': 14},
{'A': 15, 'B': 16, 'C': 17, 'D': 18, 'E': 19},
{'A': 20, 'B': 21, 'C': 22, 'D': 23, 'E': 24}]
正确示例6:传递参数orient='index'
。
#DataFrame转换为字典方法1,参数:index
df.to_dict(orient='index')
-----------------------------------------------------------------------------------------------------
{'a': {'A': 0, 'B': 1, 'C': 2, 'D': 3, 'E': 4},
'b': {'A': 5, 'B': 6, 'C': 7, 'D': 8, 'E': 9},
'c': {'A': 10, 'B': 11, 'C': 12, 'D': 13, 'E': 14},
'd': {'A': 15, 'B': 16, 'C': 17, 'D': 18, 'E': 19},
'e': {'A': 20, 'B': 21, 'C': 22, 'D': 23, 'E': 24}}
2.2Series
Series是一种一维对象,包含一个值序列和数据标签,可以认为他是一个长度固定且有序的字典,也可引用官方文档的描述:具有轴标签(包括时间序列)的一维ndarray 。
One-dimensional ndarray with axis labels (including time series).Labels need not be unique but must be a hashable type.
ps1:标签不必是唯一的,但必须是可哈希的类型。该对象同时支持基于整数和基于标签的索引。
ps2:ndarray的统计方法已被覆盖,可以自动排除丢失的数据(当前表示为NaN)。
2.2.1创建Series
Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)
作用:生成一组具有轴标签的一维ndarray数组
参数1:data:指定传递的数据
参数2:index:指定生成Series的索引
参数3:type:指定生成Series的数据类型
参数4:name:指定生成Series的名称
参数5:copy:布尔型,指定是否拷贝数据
方法1:传递一个字典构造Series,它的键将成为Series的索引,值也就成为Series的值
正确示例:使用字典构造Series,并传递name='A'
,字典的键将成为Series的索引也称显示索引。
#方法1:使用字典构造Series,并传递name='A'
sdata = {'a': 1000, 'b': 2000, 'c': 3000, 'd': 4000}
series = pd.Series(sdata, name='A')
-----------------------------------------------------------------------------------------------------
a 1000
b 2000
c 3000
d 4000
Name: A, dtype: int64
错误示例:词典的键与索引值不匹配,index
参数优先于键作为Series索引,但是没有数值。
#方法1错误示例:词典的键与索引值不匹配,index参数优先于键作为Series索引,但是没有数值
d = {'a': 1, 'b': 2, 'c': 3}
ser = pd.Series(data=d, index=['x', 'y', 'z'], name='A')
-----------------------------------------------------------------------------------------------------
x NaN
y NaN
z NaN
Name: A, dtype: float64
错误示例对比示例:
#方法1对比示例:索引和字典键匹配,那么数据和索引都会存在
d = {'a': 1, 'b': 2, 'c': 3}
ser = pd.Series(data=d, index=['a', 'b', 'c'], name='A')
-----------------------------------------------------------------------------------------------------
a 1
b 2
c 3
Name: A, dtype: int64
方法2:只传递数据,那么索引将会是线性索引也称隐式索引,即range(series.size)
。
#方法2:只传递数据,那么索引将会是线性索引
series = pd.Series([1, 2, 3], name='A')
-----------------------------------------------------------------------------------------------------
0 1
1 2
2 3
Name: A, dtype: int64
2.2.2Series索引和切片
跟DataFrame一样,不管是索引还是切片其核心目标都是找出符合要求的数据子集。
#初始化数据
sdata = {'a': 1000, 'b': 2000, 'c': 3000, 'd': 4000}
series = pd.Series(sdata, name='A')
-----------------------------------------------------------------------------------------------------
a 1000
b 2000
c 3000
d 4000
Name: A, dtype: int64
2.2.2.1索引单值
方法1:series[索引]
或者series.索引
正确示例:传递索引名称索引单值。
#索引单值方法1-1:传递索引名称索引单值
series['a']
-----------------------------------------------------------------------------------------------------
1000
#索引单值方法1-2:传递索引名称索引单值
series.a
-----------------------------------------------------------------------------------------------------
1000
对比示例:series[索引]
和series[[索引]]
是不同的,前者是索引单值,后者是切一个只有一个元素的Series实例,尽管二者的值都是相同的。
#方法1对比示例:前者是整数,后者是Series实例
series[['a']], type(series.a), type(series[['a']])
-----------------------------------------------------------------------------------------------------
a 1000
Name: A, dtype: int64 <class 'numpy.int64'> <class 'pandas.core.series.Series'>
方法2:series.loc[索引]
正确示例:使用loc方法通过索引名称索引单值,只传递索引名称。
#索引单值方法2:使用loc方法通过索引名称索引单值
series.loc['a']
-----------------------------------------------------------------------------------------------------
1000
错误示例:不同于DataFrame,不能传递另一个维度的信息,即series.loc[索引,:]
,会引发IndexingError
#索引单值方法2错误示例:传递另一个维度的信息引发IndexingError
series.loc['a', :]
-----------------------------------------------------------------------------------------------------
IndexingError: Too many indexers
方法3:series.iloc[位置]
正确示例:使用iloc方法通过索引位置索引单值,只传递索引位置。
#索引单值方法2:使用iloc方法通过索引位置索引单值
series.iloc[0]
-----------------------------------------------------------------------------------------------------
1000
对比示例:series.iloc[位置]
和series.iloc[[位置]]
其结果和loc方法一样,再次不在赘述。
错误示例:series.iloc[位置]
和series.iloc[位置, :]
其结果和loc方法一样,再次不在赘述。
ps1:Series的索引和切片只针对index而言,即axis=0因为它只有一列
ps2:Series[[]]出来的结果都是Series实例,而不是单值
2.2.2.2索引多值
方法1:series[索引1:索引2]
只能进行连续切片。
正确示例:传递两个索引名称,进行连续切片。
#传递多值方法1:传递两个索引名称,进行连续切片
series['a':'c']
-----------------------------------------------------------------------------------------------------
a 1000
b 2000
c 3000
Name: A, dtype: int64
方法2:series[[索引1, 索引2...]]
可以进行连续和不连续切片,并且能自定义切片元素的位置。
正确示例1:传递两个索引名称,进行不连续切片。
#传递多值方法2-1:递两个索引名称,进行不连续切片
series[['a', 'c']]
-----------------------------------------------------------------------------------------------------
a 1000
c 3000
Name: A, dtype: int64
正确示例2:传递两个索引名称,进行不连续切片且自定义切片元素的位置。
#传递多值方法2-2:传递两个索引名称,进行不连续切片且自定义切片元素的位置
series[['c', 'a']]
-----------------------------------------------------------------------------------------------------
c 3000
a 1000
Name: A, dtype: int64py
方法3:series.loc[索引1:索引2]
和series.loc[[索引1, 索引2...]
前者用于快速的连续切片,后者的普遍性更高,同时适用于连续和不连续切片,可以更加精确的操作。
#传递多值方法3-1:一个中括号
series.loc['a':'c']
-----------------------------------------------------------------------------------------------------
a 1000
b 2000
c 3000
Name: A, dtype: int64
#传递多值方法3-2:两个中括号
series.loc[['c', 'a']]
-----------------------------------------------------------------------------------------------------
c 3000
a 1000
Name: A, dtype: int64
方法4:series.iloc[索引位置1:索引位置2]
和series.iloc[[索引位置1, 索引位置2...]
同series.loc的使用方法一致,唯一的区别在于iloc[索引位置1:索引位置2]
不包括末尾位置。其他在此不再赘述,只提供两个示例。
#传递多值方法4-1:使用iloc方法传递位置参数索引多值
series.iloc[0:2]
-----------------------------------------------------------------------------------------------------
a 1000
b 2000
Name: A, dtype: int64
#传递多值方法4-2:使用iloc方法传递位置参数索引多值,自定义位置
series.iloc[[2, 0]]
-----------------------------------------------------------------------------------------------------
c 3000
a 1000
Name: A, dtype: int64
2.2.3Series赋值
#初始化数据
sdata = {'a': 1000, 'b': 2000, 'c': 3000, 'd': 4000}
series = pd.Series(sdata, name='A')
-----------------------------------------------------------------------------------------------------
a 1000
b 2000
c 3000
d 4000
Name: A, dtype: int64
2.2.3.1赋值单值
所有的单值索引方式都可以用来进行赋值操作,在此不再赘述索引方式,只给出相关示例。
方法1正确示例:
#赋值单值方法1-1:传递索引名称进行单值赋值
series.a = 5000
-----------------------------------------------------------------------------------------------------
a 5000
b 2000
c 3000
d 4000
Name: A, dtype: int64
#赋值单值方法1-2:传递索引名称进行单值赋值
series['a'] = 5000
-----------------------------------------------------------------------------------------------------
a 5000
b 2000
c 3000
d 4000
Name: A, dtype: int64
对比示例:如果给一个不存在的索引赋值相当于在末尾添加一个新的索引。
#方法1对比示例:如果给一个不存在的索引赋值相当于在末尾添加一个新的索引
series.loc['e'] = 5000
-----------------------------------------------------------------------------------------------------
a 1000
b 2000
c 3000
d 4000
e 5000
Name: A, dtype: int64
方法2正确示例:
#赋值单值方法2:使用loc方法传递一个索引名称进行单值赋值
series.loc['a'] = 5000
-----------------------------------------------------------------------------------------------------
a 5000
b 2000
c 3000
d 4000
Name: A, dtype: int64
方法3正确示例:
#赋值单值方法3:使用iloc方法传递一个索引号进行单值赋值
series.iloc[0] = 5000
-----------------------------------------------------------------------------------------------------
a 5000
b 2000
c 3000
d 4000
Name: A, dtype: int64
2.2.3.2赋值多值
所有的多值索引方式都可以用来进行赋值操作,在此不再赘述索引方式,只给出相关示例。
方法1正确示例:
#赋值多值方法1:传递多个索引名称进行多值赋值
series['a':'c'] = [5000, 6000, 7000]
-----------------------------------------------------------------------------------------------------
a 5000
b 6000
c 7000
d 4000
Name: A, dtype: int64
方法2正确示例:
#赋值多值方法2:双中括号,传递多个索引名称进行多值赋值
series[['a', 'c', 'b']] = [5000, 6000, 7000]
-----------------------------------------------------------------------------------------------------
a 5000
b 7000
c 6000
d 4000
Name: A, dtype: int64
方法3正确示例:
#赋值多值方法3:使用loc方法传递多个索引名称进行多值赋值
series.loc['a':'c'] = [5000, 6000, 7000]
-----------------------------------------------------------------------------------------------------
a 5000
b 6000
c 7000
d 4000
Name: A, dtype: int64
方法4正确示例:
#赋值多值方法4:使用iloc方法传递多个索引号进行多值赋值
series.iloc[0: 3] = [5000, 6000, 7000]
-----------------------------------------------------------------------------------------------------
a 5000
b 6000
c 7000
d 4000
Name: A, dtype: int64
错误示例:赋值长度不一致会引发ValueError。
#赋值多值错误示例:赋值长度不一致会引发ValueError
series.iloc[0: 3] = [5000, 6000, 7000, 8000]
-----------------------------------------------------------------------------------------------------
ValueError: cannot set using a slice indexer with a different length than the value
ps1:所有的索引赋值方式都是在原视图上进行操作的,不会生成新的实例
2.2.3.3赋值名称
Series本身和索引都有一个name属性,前者表示该Series实例的名字,后者表示索引集合的名称。
方法1:series.name=Value
和series.index.name=Value
正确示例:重新传递两个name属性值。
#赋值Series名称方法1:使用name属性赋值Series名称
series.name = 'B'
-----------------------------------------------------------------------------------------------------
a 1000
b 2000
c 3000
d 4000
Name: B, dtype: int64
#赋值索引名称方法1:使用index的name属性赋值索引名称
series.index.name = 'index'
-----------------------------------------------------------------------------------------------------
index
a 1000
b 2000
c 3000
d 4000
Name: B, dtype: int64
2.2.3.4赋值索引
方法1:series.index=Values
正确示例:传递相同长度的数组或者列表。
#赋值索引方法1:使用.index属性赋值索引
series.index = list('efgh')
-----------------------------------------------------------------------------------------------------
e 1000
f 2000
g 3000
h 4000
Name: A, dtype: int64
错误示例:传递长度不相等的数组或者列表引发ValueError。
#赋值索引方法1错误示例:传递长度不相等的数组或者列表引发ValueError
series.index = list('efghi')
-----------------------------------------------------------------------------------------------------
ValueError: Length mismatch: Expected axis has 4 elements, new values have 5 elements
2.2.4Series删除
方法1:series.drop()
drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors=‘raise’)
参数1:labels:指定要删除的索引
参数2:axis:指定要传播方向
参数3:columns:未知
参数4:level:指定删除标签的层级
参数5:inplace:布尔型,指定是否在原视图上进行操作
参数6:errors:布尔型,指定是否忽略错误
返回值:如果
inplace=True
返回None,否则返回新的Series实例
正确示例1:传递索引1
删除单个索引。
#方法1-1:使用drop方法删除单个索引
series.drop(labels='a')
-----------------------------------------------------------------------------------------------------
b 2000
c 3000
d 4000
Name: A, dtype: int64
正确示例2:传递[索引1, 索引2]
删除多个索引。
#方法1-2:使用drop方法删除多个索引
series.drop(labels=['a', 'c'])
-----------------------------------------------------------------------------------------------------
b 2000
d 4000
Name: A, dtype: int64
正确示例3:传递level
参数删除多级索引中的二级索引。
#初始化数据
midx = pd.MultiIndex(levels=[['lama', 'cow', 'falcon'],
['speed', 'weight', 'length']],
codes=[[0, 0, 0, 1, 1, 1, 2, 2, 2],
[0, 1, 2, 0, 1, 2, 0, 1, 2]])
s = pd.Series([45, 200, 1.2, 30, 250, 1.5, 320, 1, 0.3],
index=midx)
-----------------------------------------------------------------------------------------------------
lama speed 45.0
weight 200.0
length 1.2
cow speed 30.0
weight 250.0
length 1.5
falcon speed 320.0
weight 1.0
length 0.3
dtype: float64
#删除二级索引
s.drop(labels='weight', level=1)
-----------------------------------------------------------------------------------------------------
lama speed 45.0
length 1.2
cow speed 30.0
length 1.5
falcon speed 320.0
length 0.3
dtype: float64
2.2.5Series的转换
#初始化数据
sdata = {'a': 1000, 'b': 2000, 'c': 3000, 'd': 4000}
series = pd.Series(sdata, name='A')
-----------------------------------------------------------------------------------------------------
a 1000
b 2000
c 3000
d 4000
Name: A, dtype: int64
2.2.5.1转换为字典
方法1:to_dict()
方法。
to_dict(into=<class ‘dict’>)
参数1:into:指定映射类型
返回值:字典或者映射类型
正确示例:不传递任何参数。
#方法1:使用to_dict方法且不传递任何参数
series.to_dict()
-----------------------------------------------------------------------------------------------------
{'a': 1000, 'b': 2000, 'c': 3000, 'd': 4000}
2.2.5.2转换为DataFrame
方法1:to_frame()
方法。
to_frame(name=None)
参数1:name:指定新生成的DataFrame名称
返回值:DataFrame形式表示的Series
正确示例1:不传递任何参数。
#方法1-1:使用to_frame方法且不传递任何参数
series.to_frame()
-----------------------------------------------------------------------------------------------------
A
a 1000
b 2000
c 3000
d 4000
正确示例2:传递name='new'
。
#方法1-2:使用to_frame方法,传递name='new'
series.to_frame(name='new')
-----------------------------------------------------------------------------------------------------
new
a 1000
b 2000
c 3000
d 4000
2.2.5.3转换为列表
方法1:to_list()
方法。
to_list()
参数:无
返回值:列表
正确示例:不传递任何参数。
#方法1:使用to_list方法且不传递参数
series.to_list()
-----------------------------------------------------------------------------------------------------
[1000, 2000, 3000, 4000]
2.2.5.4转换为ndarray
方法1:to_numpy()
方法。
to_numpy(dtype=None, copy=False, na_value=object object, **kwargs)
参数1:dtype:指定元素类型
参数2:copy:布尔型,指定是否进行拷贝
参数3:na_value:指定缺失值
参数4:**kwargs:未知
返回值:ndarray实例
正确示例:不传递任何参数。
#方法1:使用to_numpy方法且不传递任何参数
series.to_numpy()
-----------------------------------------------------------------------------------------------------
array([1000, 2000, 3000, 4000], dtype=int64)
方法2:.values
属性。
正确示例:调用values属性获取Series的值。
#方法2:使用.values属性
series.values
-----------------------------------------------------------------------------------------------------
array([1000, 2000, 3000, 4000], dtype=int64)