目录
1.创建Dataframe
import numpy as np
import pandas as pd
# 通过np生成4*5二维数组，从0-20中随机取数，不包括末尾端20
arr1 = np.random.randint(0, 20, (4, 5))
print('arr1数据:', arr1)
# 1.通过二维数组进行创建df
df1 = pd.DataFrame(arr1, index=[1, 2, 3, 4], columns=list('abcde'))
print('通过二维数组进行创建df:', df1)
# 2.通过字典创建df,字典key作为列名，字典的value作为df的每列对应的值
dict1 = {
'a': [1, 2, 3],
'b': [3, 4, 5],
'c': [5, 6, 7]
}
df2 = pd.DataFrame(dict1, index=list('ABC'))
print('通过字典创建df:', df2)
# 3.字典中缺少的值，在df创建中默认用空填充
dict2 = [{'one': 1, ' two': 2}, {'one': 3, ' two': 4, 'three': 5}]
df3 = pd.DataFrame(dict2)
print('字典中缺少的值，在df创建中默认用空填充:',df3)
# 4.由字典中组成的字典创建df
dict3 = {
'Jack': {'math': 90, 'english': 89, 'art': 78},
'Marry': {'math': 82, 'english': 95, 'art': 92},
'Tom': {'math': 78, 'english': 67}
}
df4 = pd.DataFrame(dict3)
print('由字典中组成的字典创建df:',df4)
运行结果：
arr1数据:
[[ 1 8 4 0 16]
[19 8 0 16 16]
[ 2 16 10 16 12]
[19 0 16 16 17]]
通过二维数组进行创建df:
a b c d e
1 1 8 4 0 16
2 19 8 0 16 16
3 2 16 10 16 12
4 19 0 16 16 17
通过字典创建df:
a b c
A 1 3 5
B 2 4 6
C 3 5 7
字典中缺少的值，在df创建中默认用空填充:
one two three
0 1 2 NaN
1 3 4 5.0
由字典中组成的字典创建df:
Jack Marry Tom
math 90 82 78.0
english 89 95 67.0
art 78 92 NaN适用小案例
-
在同一个工作簿（同一个excel文件）里写入多个表格数据
import pandas as pd
dict1 = {
'name': [' rose', 'jack', 'tom'],
'age': [20, 30, 35],
'city': ['cs', 'BJ', 'SH']
}
df1 = pd.DataFrame(dict1)
dict2 = {
'product': ['A', 'B', 'c'],
'price': [20, 30, 50],
'quantity': [100, 200, 300]
}
df2 = pd.DataFrame(dict2)
print(df1)
print()
print(df2)
# 在同一个工作簿（同一个excel文件）里写入多个表格数据
with pd.ExcelWriter('zhangsan.xlsx',engine='openpyxl') as ex:
# 写入到excel中的一个sheet，索引(index=True)和列名(header=True)都写入进去
df1.to_excel(ex,sheet_name='表1',index=True,header=True)
# 写入到excel中的一个sheet，索引(index=False)和列名(header=False)都不写入进去
df2.to_excel(ex,sheet_name='表2',index=False,header=False)运行结果：
name age city
0 rose 20 cs
1 jack 30 BJ
2 tom 35 SH
product price quantity
0 A 20 100
1 B 30 200
2 c 50 300写入的文件：
2.DataFrame()对象常用属性
2.1查看df的形状n*n：shape
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
print('df原始数据:',df)
#查看df的形状n*n
print(df.shape)运行结果：
df原始数据:
name age gender
0 Jack 18 F
1 Tom 19 M
2 Mary 20 W
(3, 3)2.2获取df列名：columns
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
print('df原始数据:',df)
#获取df列名
print(df.columns)
#需tolist()转成列表使用
print(df.columns.tolist())运行结果：
df原始数据:
name age gender
0 Jack 18 F
1 Tom 19 M
2 Mary 20 W
Index(['name', 'age', 'gender'], dtype='object')
['name', 'age', 'gender']2.3获取df索引：index
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
print('df原始数据:',df)
#获取df索引
print(df.index)
#需tolist()转成列表使用
print(df.index.tolist())运行结果：
df原始数据:
name age gender
0 Jack 18 F
1 Tom 19 M
2 Mary 20 W
RangeIndex(start=0, stop=3, step=1)
[0, 1, 2]2.4获取数据类型：dtypes
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
print('df原始数据:',df)
#获取数据类型
print(df.dtypes)运行结果：
df原始数据:
name age gender
0 Jack 18 F
1 Tom 19 M
2 Mary 20 W
name object
age int64
gender object
dtype: object2.5显示前n行：head
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
print('df原始数据:',df)
#显示前2行
print('显示前2行:',df.head(2))运行结果：
df原始数据:
name age gender
0 Jack 18 F
1 Tom 19 M
2 Mary 20 W
显示前2行:
name age gender
0 Jack 18 F
1 Tom 19 M2.6显示后n行：tail
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
print('df原始数据:',df)
print('显示后2行:',df.tail(2))运行结果：
df原始数据:
name age gender
0 Jack 18 F
1 Tom 19 M
2 Mary 20 W
显示后2行:
name age gender
1 Tom 19 M
2 Mary 20 W2.7获取所有的值：values
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
print('df原始数据:',df)
print('获取所有的值:',df.values)运行结果：
df原始数据:
name age gender
0 Jack 18 F
1 Tom 19 M
2 Mary 20 W
获取所有的值:
[['Jack' 18 'F']
['Tom' 19 'M']
['Mary' 20 'W']]3.查询数据
3.1查询1列
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
print('df原始数据:')
print(df)
#查询1列
print('df的name列:')
print(df['name'])运行结果：
df原始数据:
name age gender
0 Jack 18 F
1 Tom 19 M
2 Mary 20 W
df的name列:
0 Jack
1 Tom
2 Mary3.2查询多列
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
print('df原始数据:')
print(df)
# 列名用两个[[]]
print('df的name和gender列:')
print(df[['name','gender']])运行结果：
df原始数据:
name age gender
0 Jack 18 F
1 Tom 19 M
2 Mary 20 W
df的name和gender列:
name gender
0 Jack F
1 Tom M
2 Mary W3.3取连续的n行
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
print('df原始数据:')
print(df)
#[n:m]默认是取行,不包含第m行
print('取第2行和第3行:')
print(df[1:3])运行结果：
df原始数据:
name age gender
0 Jack 18 F
1 Tom 19 M
2 Mary 20 W
取第2行和第3行:
name age gender
1 Tom 19 M
2 Mary 20 W3.4取n行n列
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
print('df原始数据:')
print(df)
#取前2行的两列
print('取前2行的前两列:')
print(df[0:2][['name','age']])
#print(df[0:2,['name','age']]) #不能通过这种方式取n行n列
#print(df[1,1]) #不能通过这种方式取行列运行结果：
df原始数据:
name age gender
0 Jack 18 F
1 Tom 19 M
2 Mary 20 W
取前2行的前两列:
name age
0 Jack 18
1 Tom 193.5通过.loc方法取值
.loc[]是通过标签索引取值，没有标签索引时，把位置索引看成标签索引
.iloc[]是通过位置索引取值
推荐用.loc[]方式取值
3.5.1取连续n行
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
df.index=list('abc')
print('df原始数据:')
print(df)
print('取连续2行:')
print(df.loc['b':'c'])运行结果：
df原始数据:
name age gender
a Jack 18 F
b Tom 19 M
c Mary 20 W
取连续2行:
name age gender
b Tom 19 M
c Mary 20 W3.5.2取连续的n行n列
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
df.index=list('abc')
print('df原始数据:')
print(df)
# 取连续的2行3列
print('取连续的2行3列:')
print(df.loc['b':'c','name':'gender'])运行结果：
df原始数据:
name age gender
a Jack 18 F
b Tom 19 M
c Mary 20 W
取连续的2行3列:
name age gender
b Tom 19 M
c Mary 20 W3.5.3取不连续的n行n列
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
df.index=list('abc')
print('df原始数据:')
print(df)
# 取不连续的2行2列
print('取不连续行列，2行2列:')
print(df.loc[['a','c'],['name','gender']])运行结果：
df原始数据:
name age gender
a Jack 18 F
b Tom 19 M
c Mary 20 W
取不连续行列，2行2列:
name gender
a Jack F
c Mary W3.5.4取某n列所有的行
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
df.index=list('abc')
print('df原始数据:')
print(df)
print('取某两列所有的行:')
print(df.loc[:,['name','age']])运行结果：
df原始数据:
name age gender
a Jack 18 F
b Tom 19 M
c Mary 20 W
取某两列所有的行:
name age
a Jack 18
b Tom 19
c Mary 203.5.5取某n行所有列
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
df.index=list('abc')
print('df原始数据:')
print(df)
print('取某一行所有列:')
print(df.loc['b',:])运行结果：
df原始数据:
name age gender
a Jack 18 F
b Tom 19 M
c Mary 20 W
取某一行所有列:
name Tom
age 19
gender M
Name: b, dtype: object3.6通过.iloc方法取值
.iloc[]是通过位置索引取值
3.6.1取连续n行
不包括结束端
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
df.index=list('abc')
print('df原始数据:')
print(df)
print('取连续2行:')
print(df.iloc[1:3])运行结果：
df原始数据:
name age gender
a Jack 18 F
b Tom 19 M
c Mary 20 W
取连续2行:
name age gender
b Tom 19 M
c Mary 20 W3.6.2取连续的n行n列
行列都不包括结束端
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
df.index=list('abc')
print('df原始数据:')
print(df)
# 取连续的2行2列
print('取连续的2行2列:')
print(df.iloc[1:3,1:3])运行结果：
df原始数据:
name age gender
a Jack 18 F
b Tom 19 M
c Mary 20 W
取连续的2行2列:
age gender
b 19 M
c 20 W3.6.3取不连续的n行n列
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
df.index=list('abc')
print('df原始数据:')
print(df)
# 取不连续的2行2列
print('取不连续行列，2行2列:')
print(df.iloc[[0,2],[0,2]])3.6.4取某n列所有的行
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
df.index=list('abc')
print('df原始数据:')
print(df)
print('取某两列所有的行:')
print(df.iloc[:,[0,2]])运行结果：
df原始数据:
name age gender
a Jack 18 F
b Tom 19 M
c Mary 20 W
取某两列所有的行:
name gender
a Jack F
b Tom M
c Mary W3.6.5取某n行所有列
dict_data = {
'name': ['Jack', 'Tom', 'Mary'],
'age': [18, 19, 20],
'gender': ['F', 'M', 'W']
}
df = pd.DataFrame(dict_data)
df.index=list('abc')
print('df原始数据:')
print(df)
print('取某一行所有列:')
print(df.iloc[1,:])运行结果：
df原始数据:
name age gender
a Jack 18 F
b Tom 19 M
c Mary 20 W
取某一行所有列:
name Tom
age 19
gender M
Name: b, dtype: object4.索引排序sort_index()
4.1按照索引升序排序
"""
DataFrame.sort_index(
axis=0,
level=None,
ascending=True,
inplace=False,
kind='quicksort',
na_position='last',
sort_remaining=True,
ignore_index=False
)
参数说明：
axis：可选参数，表示按照索引的哪个轴进行排序。默认值为0，表示按照行索引排序。
level：可选参数，表示按照多级索引的哪个级别进行排序。默认值为None，表示不使用多级索引。
ascending：可选参数，表示排序的顺序。默认值为True，表示按照升序排序。
inplace：可选参数，表示是否在原DataFrame上进行排序。默认值为False，表示返回一个新的排序后的DataFrame。
kind：可选参数，表示排序算法的类型。默认值为'quicksort'，表示使用快速排序算法。
na_position：可选参数，表示缺失值的位置。默认值为'last'，表示将缺失值放在排序的最后。
sort_remaining：可选参数，表示是否对未排序的轴进行排序。默认值为True，表示对未排序的轴进行排序。
ignore_index：可选参数，表示是否忽略排序后的索引标签。默认值为False，表示保留排序后的索引标签。
key：可调用的，可选的,如果不是 None，则在排序之前将 key 函数应用于索引值。
这类似于key内置参数sorted()函数，显著的区别在于key函数应该向量化。
它应该期待一个Index并返回一个Index相同的形状。对于 MultiIndex 输入，应用键每级.
"""
# 创建一个DataFrame示例
data = {'Name': ['John', 'Amy', 'Jason', 'Lisa'],
'Age': [25, 30, 35, 40],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}
df = pd.DataFrame(data, index=[3, 1, 2, 4])
print('df原始数据:')
print(df)
# 默认按照索引的升序排序
sorted_df = df.sort_index(ascending=True)
print('默认按照索引的升序排序:')
print(sorted_df)
运行结果：
df原始数据:
Name Age City
3 John 25 New York
1 Amy 30 Los Angeles
2 Jason 35 Chicago
4 Lisa 40 Houston
默认按照索引的升序排序:
Name Age City
1 Amy 30 Los Angeles
2 Jason 35 Chicago
3 John 25 New York
4 Lisa 40 Houston4.2按照索引降序排序
data = {'Name': ['John', 'Amy', 'Jason', 'Lisa'],
'Age': [25, 30, 35, 40],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}
df = pd.DataFrame(data, index=[3, 1, 2, 4])
print('df原始数据:')
print(df)
# 按照索引的降序排序
sorted_df = df.sort_index(ascending=False)
print('按照索引的降序排序:')
print(sorted_df)运行结果：
df原始数据:
Name Age City
3 John 25 New York
1 Amy 30 Los Angeles
2 Jason 35 Chicago
4 Lisa 40 Houston
按照索引的降序排序:
Name Age City
4 Lisa 40 Houston
3 John 25 New York
2 Jason 35 Chicago
1 Amy 30 Los Angeles4.3按照列索引的升序排序
data = {'Name': ['John', 'Amy', 'Jason', 'Lisa'],
'Age': [25, 30, 35, 40],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}
df = pd.DataFrame(data, index=[3, 1, 2, 4])
print('df原始数据:')
print(df)
# 按照列索引的升序排序
sorted_df = df.sort_index(axis=1, ascending=True)
print('按照列索引的升序排序:')
print(sorted_df)运行结果：
df原始数据:
Name Age City
3 John 25 New York
1 Amy 30 Los Angeles
2 Jason 35 Chicago
4 Lisa 40 Houston
按照列索引的升序排序:
Age City Name
3 25 New York John
1 30 Los Angeles Amy
2 35 Chicago Jason
4 40 Houston Lisa4.4按照多级索引的某个级别进行排序
df = pd.DataFrame(data, index=[['Group1', 'Group1', 'Group2', 'Group2'], [1, 2, 1, 2]], columns=['Name', 'Age', 'City'])
print('df原始数据:')
print(df)
# 按照多级索引的某个级别进行排序
sorted_df = df.sort_index(level=1, ascending=True)
print('按照多级索引的某个级别进行排序:')
print(sorted_df)运行结果：
df原始数据:
Name Age City
Group1 1 John 25 New York
2 Amy 30 Los Angeles
Group2 1 Jason 35 Chicago
2 Lisa 40 Houston
按照多级索引的某个级别进行排序:
Name Age City
Group1 1 John 25 New York
Group2 1 Jason 35 Chicago
Group1 2 Amy 30 Los Angeles
Group2 2 Lisa 40 Houston4.5在原DataFrame上进行排序
data = {'Name': ['John', 'Amy', 'Jason', 'Lisa'],
'Age': [25, 30, 35, 40],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}
df = pd.DataFrame(data, index=[3, 1, 2, 4])
print('df原始数据:')
print(df)
# 在原DataFrame上进行排序,如果inplace=False表示不改变原df
df.sort_index(inplace=False)
print('在原DataFrame上进行排序inplace=False,原df未产生变化:')
print(df)
# 在原DataFrame上进行排序，如果inplace=True表示改变原df
df.sort_index(inplace=True)
print('在原DataFrame上进行排序:')
print(df)
运行结果：
df原始数据:
Name Age City
3 John 25 New York
1 Amy 30 Los Angeles
2 Jason 35 Chicago
4 Lisa 40 Houston
在原DataFrame上进行排序inplace=False,原df未产生变化:
Name Age City
3 John 25 New York
1 Amy 30 Los Angeles
2 Jason 35 Chicago
4 Lisa 40 Houston
在原DataFrame上进行排序,原df产生了变化:
Name Age City
1 Amy 30 Los Angeles
2 Jason 35 Chicago
3 John 25 New York
4 Lisa 40 Houston5.列索引排序sort_values()
inplace参数的用法和sort_index()一样
5.1按照单个列的值进行升序排序
"""
DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, ignore_index=False, na_position='last')
参数说明：
by：必需参数，表示按照哪些列的值进行排序。可以是单个列名，也可以是列名组成的列表。
axis：可选参数，表示按照哪个轴进行排序。默认值为0，表示按照行进行排序。
ascending：可选参数，表示排序的顺序。默认值为True，表示按照升序排序。
inplace：可选参数，表示是否在原DataFrame上进行排序。默认值为False，表示返回一个新的排序后的DataFrame。
ignore_index：可选参数，表示是否忽略排序后的索引标签。默认值为False，表示保留排序后的索引标签。
na_position：可选参数，表示缺失值的位置。默认值为'last'，表示将缺失值放在排序的最后。
"""
import pandas as pd
# 创建一个DataFrame示例
data = {'Name': ['John', 'Amy', 'Jason', 'Lisa'],
'Age': [40, 30, 35, 26],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}
df = pd.DataFrame(data)
print('df原始数据:')
print(df)
# 按照单个列的值进行升序排序
sorted_df = df.sort_values(by='Age')
print('按照单个列的值进行升序排序:')
print(sorted_df)运行结果：
df原始数据:
Name Age City
0 John 40 New York
1 Amy 30 Los Angeles
2 Jason 35 Chicago
3 Lisa 26 Houston
按照单个列的值进行升序排序:
Name Age City
3 Lisa 26 Houston
1 Amy 30 Los Angeles
2 Jason 35 Chicago
0 John 40 New York5.2按照多个列的值进行排序
import pandas as pd
data = {'Name': ['John', 'Amy', 'Jason', 'Lisa'],
'Age': [40, 30, 35, 30],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}
df = pd.DataFrame(data)
print('df原始数据:')
print(df)
# 按照多个列的值进行排序
sorted_df = df.sort_values(by=['Age', 'Name'], ascending=[True, False])
print('按照多个列的值进行排序:')
print(sorted_df)运行结果：
df原始数据:
Name Age City
0 John 40 New York
1 Amy 30 Los Angeles
2 Jason 35 Chicago
3 Lisa 30 Houston
按照多个列的值进行排序:
Name Age City
3 Lisa 30 Houston
1 Amy 30 Los Angeles
2 Jason 35 Chicago
0 John 40 New York5.3按照多个列排序，并重置索引
import pandas as pd
data = {'Name': ['John', 'Amy', 'Jason', 'Lisa'],
'Age': [40, 30, 35, 30],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}
df = pd.DataFrame(data)
print('df原始数据:')
print(df)
# 根据第二列降序排序，当第二列相同时，根据第一列进行升序排序，不重置索引
df.sort_values(by = ['Age','Name'],ascending=[False,True],ignore_index=False,inplace=True)
print('根据第二列降序排序，当第二列相同时，根据第一列进行升序排序，不重置索引:')
print(df)
print()
# 根据第二列降序排序，当第二列相同时，根据第一列进行升序排序，并且重置索引，替换原索引
print('根据第二列降序排序，当第二列相同时，根据第一列进行升序排序，并且重置索引，替换原索引:')
df.sort_values(by = ['Age','Name'],ascending=[False,True],ignore_index=True,inplace=True)
print(df)运行结果：
df原始数据:
Name Age City
0 John 40 New York
1 Amy 30 Los Angeles
2 Jason 35 Chicago
3 Lisa 30 Houston
根据第二列降序排序，当第二列相同时，根据第一列进行升序排序，不重置索引:
Name Age City
0 John 40 New York
2 Jason 35 Chicago
1 Amy 30 Los Angeles
3 Lisa 30 Houston
根据第二列降序排序，当第二列相同时，根据第一列进行升序排序，并且重置索引，替换原索引:
Name Age City
0 John 40 New York
1 Jason 35 Chicago
2 Amy 30 Los Angeles
3 Lisa 30 Houston6.排名rank()
import pandas as pd
# 创建一个DataFrame示例
data = {'Name': ['John', 'Amy', 'Jason', 'Lisa'],
'Score': [75, 80, 90, 80]}
df = pd.DataFrame(data)
print('df原始数据:')
print(df)
print()
# 计算在Score列中元素的排名
print('计算在Score列中元素的排名:')
rank_df = df['Score'].rank()
print(rank_df)运行结果:
df原始数据:
Name Score
0 John 75
1 Amy 80
2 Jason 90
3 Lisa 80
计算在Score列中元素的排名:
0 1.0
1 2.5
2 4.0
3 2.57.布尔索引
import pandas as pd
df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
index=['one','two','three','four'],
columns=['a','b','c','d'])
print('df原始数据:')
print(df)
print()
# 取a列大于60的数据
con = df['a']>60
print('条件是a>60的布尔值:',con)
print('a列大于60的数据:')
df1 = df[con]
print(df1)运行结果：
df原始数据:
a b c d
one 88.600255 9.513174 15.192303 43.951904
two 60.720323 16.433654 3.028734 44.074688
three 23.338932 0.513912 49.412569 86.942637
four 25.701444 50.708913 90.057705 23.757693
条件是a>60的布尔值:
one True
two True
three False
four False
Name: a, dtype: bool
a列大于60的数据:
a b c d
one 88.600255 9.513174 15.192303 43.951904
two 60.720323 16.433654 3.028734 44.0746888.实用小案例，获取北京空气质量指数
import pandas as pd
# pd.read_html()获取网页上所有表格内容，header=0设置第一行为表头
df = pd.read_html('https://www.air-level.com/air/beijing/',header=0)[0]
print(df)运行结果：
监测站 AQI 空气质量等级 PM2.5 PM10 首要污染物
0 北京房山燕山 98 良 74 μg/m3 116 μg/m3 PM2.5
1 北京昌平镇 91 良 68 μg/m3 123 μg/m3 PM2.5
2 北京密云镇 79 良 58 μg/m3 98 μg/m3 PM2.5
3 北京定陵 78 良 57 μg/m3 95 μg/m3 PM2.5
4 北京密云新城 77 良 56 μg/m3 102 μg/m3 PM10
5 北京顺义新城 76 良 56 μg/m3 96 μg/m3 PM2.5
6 北京怀柔镇 75 良 55 μg/m3 96 μg/m3 PM2.5
7 北京平谷新城 75 良 55 μg/m3 93 μg/m3 PM2.5
8 北京怀柔新城 74 良 54 μg/m3 91 μg/m3 PM2.5
9 北京延庆夏都 62 良 38 μg/m3 72 μg/m3 PM10
10 北京延庆石河营 60 良 38 μg/m3 69 μg/m3 PM10
11 北京大兴旧宫 166 中度污染 126 μg/m3 168 μg/m3 PM2.5
12 北京万寿西宫 162 中度污染 123 μg/m3 169 μg/m3 PM2.5
13 北京东四 146 轻度污染 112 μg/m3 175 μg/m3 PM2.5
14 北京天坛 146 轻度污染 112 μg/m3 160 μg/m3 PM2.5
15 北京官园 141 轻度污染 108 μg/m3 166 μg/m3 PM2.5
16 北京丰台小屯 138 轻度污染 106 μg/m3 179 μg/m3 PM2.5
17 北京农展馆 127 轻度污染 97 μg/m3 151 μg/m3 PM2.5
18 北京丰台云岗 126 轻度污染 96 μg/m3 157 μg/m3 PM2.5
19 北京奥体中心 124 轻度污染 94 μg/m3 135 μg/m3 PM2.5
20 北京海淀万柳 122 轻度污染 93 μg/m3 156 μg/m3 PM2.5
21 北京古城 113 轻度污染 85 μg/m3 150 μg/m3 PM2.5
22 北京通州东关 113 轻度污染 85 μg/m3 132 μg/m3 PM2.5
23 北京门头沟三家店 - - - - -9.练习
import numpy as np
import pandas as pd
df = pd.DataFrame(np.random.random(size=(6,4)),index=list('abcdef'),columns=['one','two','three','four'])
print('df原始数据:')
print(df)
#查询第一行第一列
print('查询第一行第一列:')
print(df.loc['a','one'])
print(df.iloc[0,0])
#查询前3行
print('查询前3行:')
print(df.head(3))
print(df.iloc[:3])
#查询后3行
print('查询后3行:')
print(df.tail(3))
#对one列进行降序排序
print('对one列进行降序排序:')
sort_df = df.sort_values(by='one',ascending=False)
print(sort_df)
#按照索引降序排列
print('按照索引降序排列:')
sort_df = df.sort_index(ascending=False)
print(sort_df)运行结果：
df原始数据:
one two three four
a 0.909258 0.720161 0.875110 0.618486
b 0.860610 0.744329 0.193919 0.298618
c 0.976656 0.255061 0.954226 0.529841
d 0.740789 0.752703 0.022538 0.411520
e 0.176599 0.436461 0.620098 0.946948
f 0.856391 0.658529 0.729389 0.920312
查询第一行第一列:
0.9092577792355678
0.9092577792355678
查询前3行:
one two three four
a 0.909258 0.720161 0.875110 0.618486
b 0.860610 0.744329 0.193919 0.298618
c 0.976656 0.255061 0.954226 0.529841
one two three four
a 0.909258 0.720161 0.875110 0.618486
b 0.860610 0.744329 0.193919 0.298618
c 0.976656 0.255061 0.954226 0.529841
查询后3行:
one two three four
d 0.740789 0.752703 0.022538 0.411520
e 0.176599 0.436461 0.620098 0.946948
f 0.856391 0.658529 0.729389 0.920312
对one列进行降序排序:
one two three four
c 0.976656 0.255061 0.954226 0.529841
a 0.909258 0.720161 0.875110 0.618486
b 0.860610 0.744329 0.193919 0.298618
f 0.856391 0.658529 0.729389 0.920312
d 0.740789 0.752703 0.022538 0.411520
e 0.176599 0.436461 0.620098 0.946948
按照索引降序排列:
one two three four
f 0.856391 0.658529 0.729389 0.920312
e 0.176599 0.436461 0.620098 0.946948
d 0.740789 0.752703 0.022538 0.411520
c 0.976656 0.255061 0.954226 0.529841
b 0.860610 0.744329 0.193919 0.298618
a 0.909258 0.720161 0.875110 0.618486后续持续学习更新
1017
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
