pandas索引

索引

#选择行与列
import numpy as np
import pandas as pd 
df = pd.DataFrame(np.random.rand(12).reshape(3,4)*100,
                   index = ['one','two','three'],
                   columns = ['a','b','c','d'])
print(df)
data1 = df['a']
data2 = df[['a','c']]
print('*****'*5)
print(data1,type(data1))
print(data2,type(data2))
print('*****'*5)
# 按照列名选择列，只选择一列输出Series，选择多列输出Dataframe
data3 = df.loc['one']
data4 = df.loc[['one','two']]
print(data2,type(data3))
print(data3,type(data4))
# 按照index选择行，只选择一行输出Series，选择多行输出Dataframe

选择行与列

import numpy as np
import pandas as pd 
df = pd.DataFrame(np.random.rand(12).reshape(3,4)*100,
                   index = ['one','two','three'],
                   columns = ['a','b','c','d'])
print(df)
data1 = df['a']
data2 = df[['a','c']]
print(data1,type(data1))
print(data2,type(data2))
print('*****'*5)
# 按照列名选择列，只选择一列输出Series，选择多列输出Dataframe
data3 = df.loc['one']
data4 = df.loc[['one','two']]
print(data2,type(data3))
print(data3,type(data4))
# 按照index选择行，只选择一行输出Series，选择多行输出Dataframe

df.loc[] - 按index选择行

df1 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                   index = ['one','two','three','four'],
                   columns = ['a','b','c','d'])
df2 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                   columns = ['a','b','c','d'])
print(df1)
print(df2)
print('*****'*5)
data1 = df1.loc['one']
data2 = df2.loc[1]
print('单标签索引')
print(data1)
print(data2)
print('*****'*5)
# 单个标签索引，返回Series
data3 = df1.loc[['two','three','five']]
data4 = df2.loc[[3,2,1]]
print('多标签索引')
print(data3)
print(data4)
print('*****'*5)
# 多个标签索引，如果标签不存在，则返回NaN
# 顺序可变
data5 = df1.loc['one':'three']
data6 = df2.loc[1:3]
print(data5)
print(data6)
print('切片索引')
# 可以做切片对象
# 末端包含

布尔型索引

# 和Series原理相同
import numpy as np
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('*****'*5)
b1 = df < 20
print(b1,type(b1))
print(df[b1])  # 也可以书写为 df[df < 20]
print('*****'*5)
# 不做索引则会对数据每个值进行判断
# 索引结果保留 所有数据：True返回原数据，False返回值为NaN
b2 = df['a'] > 50
print(b2,type(b2))
print(df[b2])  # 也可以书写为 df[df['a'] > 50]
print('*****'*5)
# 单列做判断
# 索引结果保留 单列判断为True的行数据，包括其他列
b3 = df[['a','b']] > 50
print(b3,type(b3))
print(df[b3])  # 也可以书写为 df[df[['a','b']] > 50]
print('*****'*5)
# 多列做判断
# 索引结果保留 所有数据：True返回原数据，False返回值为NaN
b4 = df.loc[['one','three']] < 50
print(b4,type(b4))
print(df[b4])  # 也可以书写为 df[df.loc[['one','three']] < 50]
# 多行做判断
# 索引结果保留 所有数据：True返回原数据，False返回值为NaN

Dataframe：基本技巧

#数据查看、转置
df = pd.DataFrame(np.random.rand(16).reshape(8,2)*100,
                   columns = ['a','b'])
print(df.head(2))
print(df.tail())
print('*****'*5)
# .head()查看头部数据
# .tail()查看尾部数据
# 默认查看5条
print(df.T)
print('*****'*5)
# .T 转置
# 添加与修改
df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                   columns = ['a','b','c','d'])
print(df)
print('*****'*5)
df['e'] = 10
df.loc[4] = 20
print(df)
# 新增列/行并赋值
df['e'] = 20
df[['a','c']] = 100
print('*****'*5)
print(df)
# 索引后直接修改值
# 删除  del / drop()
df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                   columns = ['a','b','c','d'])
print(df)
print('*****'*5)
del df['a']
print('*****'*5)
print(df)
print('*****'*5)
# del语句 - 删除列
print(df.drop(0))
print('*****'*5)
print(df.drop([1,2]))
print('*****'*5)
print(df)
print('*****'*5)
# drop()删除行，inplace=False → 删除后生成新的数据，不改变原数据
print(df.drop(['d'], axis = 1))
print(df)
# drop()删除列，需要加上axis = 1，inplace=False → 删除后生成新的数据，不改变原数据

多重索引：比如同时索引行和列

# 先选择列再选择行 —— 相当于对于一个数据，先筛选字段，再选择数据量
df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                   index = ['one','two','three','four'],
                   columns = ['a','b','c','d'])
print(df)
print('******'*5)
print(df['a'].loc[['one','three']])   # 选择a列的one，three行
print('*****'*5)
print(df[['b','c','d']].iloc[::2])   # 选择b，c，d列的one，three行
print('*****'*5)
print(df[df['a'] < 50].iloc[:2])   # 选择满足判断索引的前两行数据
# 对齐
df1 = pd.DataFrame(np.random.randn(10, 4),  columns = ['a','b','c','d'])
df2 = pd.DataFrame(np.random.randn(7, 3), columns = ['a','b','c','d'])
print('*****'*5)
print(df1 + df2)
# DataFrame对象之间的数据自动按照列和索引（行标签）对齐

排序1 - 按值排序 .sort_values

# 同样适用于Series
df1 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                   columns = ['a','b','c','d'])
print(df1)
print('*****'*5)
print(df1.sort_values(['a'], ascending = True))  # 升序
print('*****'*5)
print(df1.sort_values(['a'], ascending = False))  # 降序
# ascending参数：设置升序降序，默认升序
# 单列排序
df2 = pd.DataFrame({'a':[2,5,6,9,5,5,8,,8,6,9,8],
                  'b':list(range(8)),
                  'c':list(range(8,0,-1))})
print('*****'*5)
print(df2)
print(df2.sort_values(['a','c']))
# 多列排序，按列顺序排序

排序2 - 索引排序 .sort_index

df1 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                  index = [5,4,3,2],
                   columns = ['a','b','c','d'])
df2 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                  index = ['f','i','j','k'],
                   columns = ['a','b','c','d'])
print(df1)
print(df1.sort_index())
print('*****'*5)
print(df2)
print(df2.sort_index())
# 按照index排序
# 默认 ascending=True, inplace=False