目录
复习Series结构
Series，由一组数据值和一组标签组成，其中标签与数据值具有对应关系。
一、Series结构创建
pd.Series(data=None, index=None, dtype=None, name=None, copy=False)
data:输入的数据，可以是列表、常量、ndarray数组等。如果是字典，则保持参数顺序。
index:索引值，必须是可散列的（不可变数据类型（str,bytes和数据类型）），并且与数据具有相同的长度，允许使用非唯一索引值。如果未提供，将默认为RangeIndex(0,1,2,…,n)
dtype:输出系列的数据类型，如果未指定，将从数据中推断
copy:表示对data进行拷贝，默认为False,仅影响Series和ndarray数组。
data参数：
例如：
a_list = [3,10,3,4,5]
s1 = pd.Series(a_list)
np_rand = np.arange(1,6)
s2 = pd.Series(np_rand)
a_dic = {'a':1, 'b':2, 'c':3}
s3 = pd.Series(data=a_dic)
print("s1: \n",s1, sep='')
print("="*50)
print("s2:\n",s2, sep='')
print("="*50)
print("s3:\n",s3, sep='')
输出：
s1:
0 3
1 10
2 3
3 4
4 5
dtype: int64
==================================================
s2:
0 1
1 2
2 3
3 4
4 5
dtype: int32
==================================================
s3:
a 1
b 2
c 3
dtype: int64
可以通过index和values属性取得对应的标签和值：s1.index；s1.values
标签存在数值型的数据，不能使用标签的下标获取值;
标签非数值型，可以用标签取数据，也可以用下标取数据.
获取不存在的索引值对应数据，会报错，但是可以赋值，相当于新增数据
index参数:
必须是可散列的（不可变数据类型（str,bytes和数值类型）），与数据具有相同的长度。如果未提供，将默认为RangeIndex(0,1,2,…,n)
1.使用”显示索引“的方法定义索引标签：data = np.array(['a','b','c','d']) s = pd.Series(data,index=[100,101,102,103])
2.当传递的索引值未匹配对应的字典键时，使用NaN（非数字）填充d = {'a':1, 'b':2, 'c':3} ser = pd.Series(data=d, index=['x','b','z']) #x,z对应的数值以NaN填充
name参数：
以给一个Series对象命名，也可以给一个Series数组中的索引列起一个名字
如：
data1 = pd.Series(a_dic)\n data1.name = "dic_Data"\n data1.index.name = "index_name"
copy参数:
对data进行拷贝，默认为False,仅影响Series和ndarry数组
源数据非Series和ndarray类型时,改变Series数据，源数据不改变。
二、Series的索引/切片
索引：
位置索引和标签索引刚好一致，会使用标签索引，不存在负数的标签索引
切片：
Series使用标签切片时，其末端是包含的。s1 = pd.Series([6,7,8,9,10],index = ['a','b','c','d','e']) s1["b":"d"]
Series使用位置切片时，其末端不包含（与python切片一样）。s = pd.Series([1,2,3,4,5],index=['a','b','c','d','e']) print(s[1:4])
三、Series数据结构 基本技巧
1.查看前几条和后几条数据
s.head()#默认查看前5条数据
s.head(1)#默认查看前1条数据
s.tail()# 默认查看后5条数据
2.重新索引 reindex
新索引在上一个索引中不存在，生成新对象时，对应的值，设置为NaN：
s = pd.Series(np.random.rand(5),index=list("abcde"))
s1 = s.reindex(list("cde12"))#12对应的值设置为NaN
设置填充值：s2 = s.reindex(list("cde12"), fill_value=0)
3.对齐运算
如果没对齐得位置则补NaN
s1 = pd.Series(np.random.rand(3),index=["kelly","Anne","T-C"])
s2 = pd.Series(np.random.rand(3), index=["Anne", "Kelly", "Lily"])
s1+s2 #"kelly"和"T-C"对应的数值为NaN
4.删除和添加
删除：返回删除后的值，原值不改变，默认Inplace=Falses1 = s.drop("a")
想要改变原值：s.drop("a",inplace=True)
添加：直接新增数据即可
新内容：DataFrame数据类型
DataFrame是一个表格型的数据结构，既有行标签（index),又有列标签（columns),也被称为异构数据表，异构指的是表格中每列的数据类型可以不同，比如：
对于每列数据：
每一列标签对应的数据类型不同。
DataFrame的每一列都可以看成一个Series结构，只不过DataFrame为每列数据值增加了一个列标签，因此DataFrame是在Series基础上演变而来的。
同Series一样，DataFrame自带行标签索引，默认为隐式索引，即从0开始递增，行标签与DataFrame中的数据项一一对应，上述表格行标签从0到3，共4条数据，也可以通过”显示索引“的方式设置行标签。
一、创建DataFrame对象
pandas.DataFrame(data=None, index=None, columns=None,dtype=None,copy=None)
data:输入的数据，可以是ndarray,series,list,dict,标量以及一个DataFrame
index:行标签，如果没有传递index值，则默认行标签是RangeIndex（0，1，2，3...n),n代表data元素个数
columns:列标签，如果没有传递columns值，则默认标签是RangeIndex（0，1，2...n)
dtype:要强制的数据类型，只允许使用一种数据类型，如果没有，自行推断。
copy:从输入复制数据。对于dict数据，copy=True,重新复制一份。对于dataFrame或ndarray输入，copy=False.
1.使用普通列表创建:
data = [1,2,3,4]
df = pd.DataFrame(data)
print(df)
输出：
0
0 1
1 2
2 3
3 4
2.使用嵌套列表创建
#列表中每个元素代表一行数据
data = [["xiaowang",20],["Lily",30],["Anne",40]]
#未分配列标签
df = pd.DataFrame(data)
print(df)
输出：
0 1
0 xiaowang 20
1 Lily 30
2 Anne 40
分配列标签：
data = [["xiaowang",20],["Lily",30],["Anne",40]]
df = pd.DataFrame(data,columns=['Name','Age'])
print(df)
输出：
Name Age
0 xiaowang 20
1 Lily 30
2 Anne 40
3.指定数值元素的数据类型为float
注意：dtype只能设置一个，设置多个列的数据类型，需要使用其他方式
data = [['xiaoming',20,"男",5000],['lily',30,"男",8000],["Anne",40,"女",10000]]
#分配列标签
#df = pd.DataFrame(data,columns=['Name','Age',"gender","salary"],dtype=[str,int,,str,float])#错误
df = pd.DataFrame(data,columns=['Name','Age',"gender","salary"],dtype=int)
#int满足某列特征，会自动使用，不满足，则自动识别
print(df)
print(df['salary'].dtype)
print(df['gender'].dtype)
输出：
Name Age gender salary
0 xiaoming 20 男 5000
1 lily 30 男 8000
2 Anne 40 女 10000
int32
object
4.列表嵌套字典创建DataFrame对象
列表嵌套字典可以作为输入数据传递给DataFrame构造函数，默认情况下，字典的键被用作列名。
data = [{'a':1, "b":2},{"a":5,"b":10,"c":20}]
#df = pd.DataFrame(data)
df = pd.DataFrame(data, index=["first","second"])
print(df)
输出：
a b c
first 1 2 NaN
second 5 10 20.0
注意：如果其中某个元素值缺失，也就是字典的key无法找到对应的value,将使用NaN代替。
如果使用列表嵌套字典创建一个DataFrame对象，可以设置结果需要的那些列。
data = [{'a':1, "b":2},{"a":5,"b":10,"c":20}]
df1 = pd.DataFrame(data,index=["first","second"], columns=['a','b'])
#注意：因为b1在字典键中不存在，所以对应值为NaN
df2 = pd.DataFrame(data,index = ['first','second'], columns=['a','b1'])
print("=========df1========")
print(df1)
print("=========df2========")
print(df2)
输出：
=========df1========
a b
first 1 2
second 5 10
=========df2========
a b1
first 1 NaN
second 5 NaN
5.字典嵌套列表创建
data字典中，键对应的值元素长度必须相同（也就是列表长度相同）。如果传递了索引，那么索引的长度应该等于数组的长度；如果没有传递索引，那么默认情况下，索引是RangeIndex（0，1，2…n),其中n代表数组长度。
data = {"Name":['关羽','刘备','张飞','曹操'],'Age':[28,34,29,42]}
#通过字典创建DataFrame
df = pd.DataFrame(data)
print(df)
#输出行标签
print(df.index)
#输出列标签
print(df.columns)
输出：
Name Age
0 关羽 28
1 刘备 34
2 张飞 29
3 曹操 42
RangeIndex(start=0, stop=4, step=1)
Index(['Name', 'Age'], dtype='object')
添加自定义的行标签：
data = {"Name":['关羽','刘备','张飞','曹操'],'Age':[28,34,29,42]}
index = ["rank1", "rank2", "rank3", "rank4"]
df = pd.DataFrame(data, index=index)
print(df)
#输出行标签
print(df.index)
#输出列标签
print(df.columns)
输出：
Name Age
rank1 关羽 28
rank2 刘备 34
rank3 张飞 29
rank4 曹操 42
Index(['rank1', 'rank2', 'rank3', 'rank4'], dtype='object')
Index(['Name', 'Age'], dtype='object')
6.Series创建DataFrame对象
输出结果的行索引是所有index的合集
d = {'one':pd.Series([1,2,3],index=['a','b','c']),
'two':pd.Series([1,2,3,4],index=['a','b','c','d'])}
df = pd.DataFrame(d)
print(df)
type(np.NaN)
输出：
one two
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 4
float
注意：对于one列而言，行索引d没有对应的值，为NaN .
实例：建一个DataFrame结构的对象：
data = {
"Name":pd.Series(['xiaoming','Lily','Anne']),
"Age":pd.Series([20,30,40],dtype=float),
"gender":pd.Series(["男","男","女"]),
"salary":pd.Series([5000,8000,10000],dtype=float)
}
df = pd.DataFrame(data)
df
输出：
二、列操作DataFrame
DataFrame可以使用列标签来完成数据的选取、添加和删除操作。
1.选取数据列
data = {"Name":['关羽','刘备','张飞','曹操'],'Age':[28,34,29,42]}
index = ["rank1", "rank2", "rank3", "rank4"]
df = pd.DataFrame(data, index=index)
print(df)
print("*"*20)
print(df['Name'])
print("*"*20)
print(df['Age'])
输出：
Name Age
rank1 关羽 28
rank2 刘备 34
rank3 张飞 29
rank4 曹操 42
********************
rank1 关羽
rank2 刘备
rank3 张飞
rank4 曹操
Name: Name, dtype: object
********************
rank1 28
rank2 34
rank3 29
rank4 42
Name: Age, dtype: int64
df选取多列：
print("=======df[['Name','Age']]:df选取多列=======")
print(df[['Name','Age']])
#注意列不是能使用切片选取多列
print("*"*20)
print(df['Name':'Age'])#空DataFrame
输出：
=======df[['Name','Age']]:df选取多列=======
Name Age
rank1 关羽 28
rank2 刘备 34
rank3 张飞 29
rank4 曹操 42
********************
Empty DataFrame
Columns: [Name, Age]
Index: []
没有办法直接通过标签位置去获取列：df[1]# 报错
2.列添加
使用columns列索引可以实现添加新的数据列，示例：
d = {'one':pd.Series([1,2,3],index=['a','b','c']),
'two':pd.Series([1,2,3,4],index=['a','b','c','d'])}
df = pd.DataFrame(d)
# 使用df['列']=值，插入新的数据列
print("=======通过Series添加一个新的列======：")
df['three'] = pd.Series([10,20,30],index=['a','b','c'])
print(df)
#将已经存在的数据列相加运算，从而创建一个新的列
print("=======将已经存在的数据列相加运算，从而创建一个新的列======：")
df['four'] = df['one']+df['three']
print(df)
输出：
=======通过Series添加一个新的列======：
one two three
a 1.0 1 10.0
b 2.0 2 20.0
c 3.0 3 30.0
d NaN 4 NaN
=======将已经存在的数据列相加运算，从而创建一个新的列======：
one two three four
a 1.0 1 10.0 11.0
b 2.0 2 20.0 22.0
c 3.0 3 30.0 33.0
d NaN 4 NaN NaN
insert（）方法添加
df.insert(loc, column, value, allow_duplicates=False)
loc:整型，插入索引，必须验证0<=loc<=len(列）
column:插入列的标签，类型可以是（字符串/数字/散列对象)
value:数值，Series或者数组
allow_duplicates:允许重复，可以有相同的列标签数据，默认为false
info = [['王杰', 18],['李杰', 19],['刘杰',17]]
df = pd.DataFrame(info,columns=['name','age'])
print(df)
#注意是column参数
#数值i代表插入到column列表的索引位置
df.insert(2,column='score',value=[91,90,75])
print("=====df.insert插入数据=====")
print(df)
输出：
name age
0 王杰 18
1 李杰 19
2 刘杰 17
=====df.insert插入数据=====
name age score
0 王杰 18 91
1 李杰 19 90
2 刘杰 17 75
可以添加重复列标签数据：
df.insert(1,column='score',value=[80,70,90],allow_duplicates=True)
print(df['score'])
输出：
score score
0 80 91
1 70 90
2 90 75
name score age score
0 王杰 80 18 91
1 李杰 70 19 90
2 刘杰 90 17 75
df.insert(1,column='score',value=[80,70,90])#错误
2.删除数据列：
通过**del()和pop()**都能够删除DataFrame中的数据列，pop有返回值
import pandas as pd
d = {'one':pd.Series([1,2,3],index=['a','b','c']),
'two':pd.Series([1,2,3,4],index=['a','b','c','d']),
'three':pd.Series([10,20,30],index=['a','b','c'])}
df = pd.DataFrame(d)
print(df)
#使用del删除
del df['one']
print("=========del df['one']==========")
print(df)
#使用pop方法删除
res_pop = df.pop('two')
print(df)
res_pop
输出：
one two three
a 1.0 1 10.0
b 2.0 2 20.0
c 3.0 3 30.0
d NaN 4 NaN
=========del df['one']==========
two three
a 1 10.0
b 2 20.0
c 3 30.0
d 4 NaN
three
a 10.0
b 20.0
c 30.0
d NaN
a 1
b 2
c 3
d 4
Name: two, dtype: int64
三、行操作DataFrame：
1.标签选取
行操作需要借助loc属性来完成，按标签或布尔数组访问一组行和列
d = {'one':pd.Series([1,2,3],index=['a','b','c']),
'two':pd.Series([1,2,3,4],index=['a','b','c','d'])}
df = pd.DataFrame(d)
print("===========df原始数据========")
print(df)
#确定标签为d的数据
print("==========标签为b的数据========")
print(df.loc['b'])
输出：
===========df原始数据========
one two
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 4
==========标签为b的数据========
one 2.0
two 2.0
Name: b, dtype: float64
**注意：**loc允许接受两个参数分别是行和列
#b行 one列交叉的数据
df.loc['b','one']
输出：2.0
行和列还可以使用切片
#标签为b的行到标签为d的行，对应标签为one的列
df.loc['b':'d',"one"] #注意使用行标签切片，包含结束的行
输出：
b 2.0
c 3.0
d NaN
Name: one, dtype: float64
还可以：
df.loc[['a','b'],['one','two']]
#这里两个 参数，第一个代表行，第二个代表列
输出：
2.数值型索引和切片
使用数值型索引 需要使用iloc属性
直接使用索引，会优先查找的是列标签，如果找不到会报错，列没有位置索引
1.可以使用iloc:行基于整数位置的按位置选择索引
2.切片操作多行选取
data = {"Name":['关羽','刘备','张飞','曹操'],'Age':[28,34,29,42]}
index = ["rank1", "rank2", "rank3", "rank4"]
df = pd.DataFrame(data, index=index)
#获得位置索引1行到3行，但是不包括3的数据
print("=========df.iloc[1:3]:========")
print(df.iloc[1:3])
输出：
=========df.iloc[1:3]:========
Name Age
rank2 刘备 34
rank3 张飞 29
使用切片直接提取行：
print("=======df[1:3]=======")
print(df[1:3])
输出：
=======df[1:3]=======
Name Age
rank2 刘备 34
rank3 张飞 29
4.添加数据行
使用append()函数，可以将新的数据行添加到DataFrame中，该函数会在行末尾追加数据行
df.append(other, ignore_index=False, verify_integrity=False, sort=False)
将”other"追加到调用者的末尾，返回一个新对象，“other"行中不在调用者中的列将作为新列添加。
other:DataFrame或Series/dict类对象，或这些对象的列表
ignore_index:默认为False,若为True将不适用Index标签
verity_integrity:默认为False，若为True,则在创建具有重复项的索引时引发ValueError
sort:排序
1.追加字典
data = {
'Name':['关羽','刘备','张飞','曹操'],
"Age":[28,34,29,42],
"Salary":[5000,8000,4500,10000]
}
df = pd.DataFrame(data)
d2 = {"Name":"诸葛亮","Age":30}
#在行末追加新数据行
df3 = df.append(d2,ignore_index=True)#需要添加 ignore_index=True
print(df3)
输出：
Name Age Salary
0 关羽 28 5000.0
1 刘备 34 8000.0
2 张飞 29 4500.0
3 曹操 42 10000.0
4 诸葛亮 30 NaN
2.追加Series
d2 = {"Name":"诸葛亮","Age":30}
s = pd.Series(d2, name="a")
df3 = df.append(s)
print(df3)
输出：
Name Age Salary
0 关羽 28 5000.0
1 刘备 34 8000.0
2 张飞 29 4500.0
3 曹操 42 10000.0
a 诸葛亮 30 NaN
3.追加列表
如果list是一维的，则以列的形式追加
如果list是二维的，则以行的形式追加
如果list是三维的，只添加一个值
注意：使用append可能会出现相同的index,想避免的话，可以使用ignore_index=True
a_1 = [[10,"20",30]]
df4 = df.append(a_1)
print(df4)
df5 = df.append(a_1,ignore_index=True)
print(df5)
输出：
0 1 2 Age Name Salary
0 NaN NaN NaN 28.0 关羽 5000.0
1 NaN NaN NaN 34.0 刘备 8000.0
2 NaN NaN NaN 29.0 张飞 4500.0
3 NaN NaN NaN 42.0 曹操 10000.0
0 10.0 20 30.0 NaN NaN NaN
0 1 2 Age Name Salary
0 NaN NaN NaN 28.0 关羽 5000.0
1 NaN NaN NaN 34.0 刘备 8000.0
2 NaN NaN NaN 29.0 张飞 4500.0
3 NaN NaN NaN 42.0 曹操 10000.0
4 10.0 20 30.0 NaN NaN NaN
同列名追加：
data = {
'Name':['关羽','刘备','张飞','曹操'],
"Age":[28,34,29,42],
"Salary":[5000,8000,4500,10000]
}
df = pd.DataFrame(data)
a_1 = [[10,"20",30],[2,5,6]]
df2 = pd.DataFrame(a_1, columns=["Name","Age","Salary"])
df4 = df.append(df2)
print(df4)
输出：
Name Age Salary
0 关羽 28 5000
1 刘备 34 8000
2 张飞 29 4500
3 曹操 42 10000
0 10 20 30
1 2 5 6
新建DataFrame对象
data = [
[1,2,3,4],
[5,6,7,8]
]
df = pd.DataFrame(data)
print(df)
list是一维，以列的形式追加
a_1 = [10,20]
df3 = df.append(a_1)
print(df3)
输出：
0 1 2 3
0 1 2.0 3.0 4.0
1 5 6.0 7.0 8.0
0 10 NaN NaN NaN
1 20 NaN NaN NaN
ignore_index=True：
a_1 = [10,20]
df3 = df.append(a_1,ignore_index=True)
print(df3)
输出：
0 1 2 3
0 1 2.0 3.0 4.0
1 5 6.0 7.0 8.0
2 10 NaN NaN NaN
3 20 NaN NaN NaN
二维追加刚才已举例，下面是三维：
a_1 = [10,20]
df3 = df.append(a_1)
print(df3)
输出：
a_1 = [10,20]
df3 = df.append(a_1)
print(df3)
5.删除数据行
可以使用行索引标签，从DataFrame中删除某一行数据，如索引标签存在重复，将一起被删除，
df = pd.DataFrame([[1,2],[3,4]], columns = ['a','b'])
df2 = pd.DataFrame([[5,6],[7,8]], columns = ['a','b'])
df = df.append(df2)
print("========源数据df=======")
print(df)
df1 = df.drop(0)
print("========修改后的数据df1=======")
print(df1)
print("========源数据df=======")
print(df)
输出：
========源数据df=======
a b
0 1 2
1 3 4
0 5 6
1 7 8
========修改后的数据df1=======
a b
1 3 4
1 7 8
========源数据df=======
a b
0 1 2
1 3 4
0 5 6
1 7 8
四、DataFrame常用的属性和方法
新建一个DataFrame对象：
data = {
'Name':['关羽','刘备','张飞','曹操'],
"Age":[28,34,29,42],
"Salary":[5000,8000,4500,10000]
}
df = pd.DataFrame(data)
df
1.转置T
返回DataFrame的转置，也就是把行和列交换df.T
输出：
2.axes
返回一个行标签、列标签组成的列表
print(df.axes)
[df.index,df.columns]
输出：
3.dtypes
返回Series，每一列的数据类型df.dtypes
输出：
Name object
Age int64
Salary int64
dtype: object
4.empty
返回一个布尔值，判断输出的数据对象是否为空，若为true则表示对象为空df.empty
输出：False
若：
empty_df = pd.DataFrame()
empty_df.empty
输出：True
使用场景：
def my_fun(df):
#如果为真，进行操作
if not df.empty:
print("提供的数据正常")
else:
#不为真
print("提供的数据为空")
#df ----有数据，df.empty没数据
my_fun(df)
输出：提供的数据正常
如果给DataFrame数据类型直接判断真假，报错：
5.columns
返回DataFrame所有列标签df.columns
输出：
Index(['Name', 'Age', 'Salary'], dtype='object')
可以通过df.columns的个数获取DataFrame列个数：len(df.columns)
输出：3
df.columns.size
输出：3
6.shape
返回一个元组，获取行数和列数，表示了DataFrame维度df.shape
输出：(4, 3)
row_num,column_num = df.shape
print(row_num,column_num)
输出：
4 3
7.values
以ndarray数组的形式返回DataFrame中的数据df.values
输出：
array([['关羽', 28, 5000],
['刘备', 34, 8000],
['张飞', 29, 4500],
['曹操', 42, 10000]], dtype=object)
8.head()&tail()查看数据
获取前3行数据df.head(3)
输出：
获取后3行数据df.tail(3)
输出：
9.修改标签名renanem()
DataFrame.rename(index=None, columns=None, inplace=False)
index:修改后的行标签
columns:修改后的列标签
inplace:默认为False，不改变源数据，返回修改后的数据。True更改源数据
可以修改部分行和列
打印dfdf
修改变量df的行标签:df.rename(index={1:"row2",2:"row3"})
修改变量df的列标签df.rename(columns = {"Name":"name","Age":"age"})
输出：
再次打印df,源数据不改变df
添加inplace参数，修改源数据：
df.rename(index={1:"row2",2:"row3"},columns = {"Name":"name","Age":"age"},inplace=True)
df
输出（源数据已改变）：
10.info()函数
用于打印DataFrame的简要摘要，显示有关DataFrame的信息，包括索引的数据类型dtype和列的数据类型dtype,非空值的数据和内存使用情况
给df追加一组数据
#创建一组数组
data = {"name":"诸葛亮","age":30}
#将数据追加到df数据中
df = df.append(data, ignore_index = True)
df
查看信息df.info()
11.df.sort_index()
sort_index(axis=0, ascending=True, inplace=False)
作用：默认根据行标签对所有行排序，或根据列标签对所有列排序，或根据指定某列或某行对行排序
注意：df.sort_index()可以完成和df.sort_values()完全相同的功能，但python更推荐用只用df.sort_index()对“根据行标签”和“根据列标签”排序，其他排序方式用df.sort_values().
axis:0按照行名排序，1按照列名排序
ascending:默认True升序排列；False降序排列
inplace:默认False，否则排序之后的数据直接替换原来的数据。
新建一个DataFrame对象：
df = pd.DataFrame({'b':[1,2,2,3],'a':[4,3,2,1],'c':[1,3,8,2]},index=[2,0,1,3])
df
默认按“行标签”升序排序，或df.sort_index(axis=0，ascending=True)
df.sort_index()
输出：
按“列标签”排序升序
df.sort_index(axis=1)
输出：
设置inplace = True：
df.sort_index(axis=1,inplace = True)
df
输出：
12.df.sort_values()
DataFrame.sort_values(by,axis=0,ascending=True,inplace=False,kind="quicksort",na_position='last')
作用：即可以根据列数据，也可以根据行数据排序
注意：必须指定by参数，即必须指定哪几行或哪几列；无法根据index名和columns名排序（由sort_index()执行）
by:str or list of str:如果axis=0,那么by="列名";如果axis=1,那么by="行名"
axis:{0 or "index",1 or "columns"},default=0,默认按照列排序，即纵向排序；如果为1，则是横向排序。
ascending：布尔型，是否用排序后的数据框替换现有的数据框。
na_position:{'first','last'},default 'last',默认缺失值排在最后面
df = pd.DataFrame({'b':[1,2,2,3],'a':[4,3,2,1],'c':[1,3,8,2]},index=[2,0,1,3])
df
输出：
按b列升序排序：
#等同于df.sort_values(by='b',axis=0)
df.sort_values(by='b')
输出：
先按b列降序，再按a列升序排序：
df.sort_values(by=['b','a'],ascending=[False,True])
#等同于df.sort_values{by={'b','a'},axis=0,ascending={False,True}}
输出
按行3升序排列df.sort_values(by=3,axis=1)
输出：
按行3升序，行0降排列：
df.sort_values(by=[3,0],axis=1,ascending=[True,False])
输出：
五、附：
注意：
一组数据，字典的value只有一个值，创建DataFrame会报错
dict_1 = {"Name":"诸葛亮","Age":30}
df = pd.DataFrame(dict_1)
df
修改方案1：将字典的value修改为列表
dict_1 = {"Name":["诸葛亮"],"Age":[30]}
df = pd.DataFrame(dict_1)
df
输出：
修改方案2：创建df时添加一个index参数为[0]
dict_1 = {"Name":["诸葛亮"],"Age":[30]}
df = pd.DataFrame(dict_1,index=[0])
df
输出：
378
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
