第二章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)
3547
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
