pandas之dataframe

DataFrame数据结构
是pandas最常用的数据类型
对象是由多个Series增加一个索引后组成的一种表格类型数据结构

1. 行索引：表明不同行，横向索引，叫index 0轴，axis=0
2. 列索引：表明不同列，纵向索引，叫coluns 1轴，axis=1

创建：

1. 列表创建：ndarray数组创建
2. 字典创建：字典内嵌列表，要求内部列表等长
3. 字典内嵌字典：内部字典不需要等长；字典内嵌Series，等同嵌套字典

# 列表创建，默认索引
pd.DataFrame([[1,2,3],[4,5,6],[7,8,9]])
# 列表创建
pd.DataFrame([[1,2,3],[4,5,6],[7,8,9]],index=['a','b','c'],columns=['e','f','g'])
x = pd.DataFrame([
    ['张三',18,False,100],
    ['李四',28,True,90],
    ['王五',38,True,80],
],index=[1,2,3],columns=['姓名','年龄','性别','分数'])

x.values
x.columns
x.index
x.index.name = '编号'

　　

# 使用numpy数组创建
pd.DataFrame(np.arange(10).reshape(2,5))

#字典创建,key相当于列索引
pd.DataFrame(
{
    'name': ['zhangsan', 'lisi', 'wangwu'],
    'age': [18,28,23],
    'gender': [True, False,False],
    'score': [100,90,80]
})

#字典嵌套字典，内部字典的索引相当于行索引，没有值的时候也不会报错
pd.DataFrame(
{
    'name': {1:'zhangsan', 2:'lisi', 3:'wangwu'},
    'age': {1:18,2:28},
    'gender': {1:True, 2:False,3:False},
    'score': {1:100,2:90,3:80}
})
pd.DataFrame(
{
    'name': pd.Series({1:'zhangsan', 2:'lisi', 3:'wangwu'}),
    'age': pd.Series({1:18,2:28}),
    'gender': pd.Series({1:True, 2:False,3:False}),
    'score': pd.Series({1:100,2:90,3:80})
})
pd.DataFrame(
{
    'name': pd.Series(['zhangsan', 'lisi', 'wangwu']),
    'age': pd.Series([18,23]),
    'gender': pd.Series([True, False,False]),
    'score': pd.Series([100,90,80])
})

# 字典或Series类型自带的索引，直接修改，相当于查询,没有的字段或者没有的数据显示nan
pd.DataFrame(
{
    'name': pd.Series({1:'zhangsan', 2:'lisi', 3:'wangwu'}),
    'age': pd.Series({1:18,2:28}),
    'gender': pd.Series({1:True, 2:False,3:False}),
    'score': pd.Series({1:100,2:90,3:80})
},index=[1,2,6,8],columns=['name','age','address'])

　　

DataFrame整体查询
a.info() 整体信息，查看数据是否异常

• 有没有缺失值
• 列数据类型是否正确

a.describe()整体统计指标

• count:计数
• mean：平均值
• std：标准差,离散程度
• 四分位数：min，q1,p2(中位数),max

a.head()前5行
a.tail()后5行

常用属性

# 常用属性
a.shape #表格形状，行数，列数
a.dtypes #列数据类型
a.index #行所以
a.columns #列索引
a.values #对象值 展示2维ndarray数组 a.values[0,5] 等同于 a.values[0][5]

　　

a_values = [
    [ "张秀英", 0, 82,171, 66,"阜新市",73],
    ["毛桂英", 1, 18, 173, 56,"金华市",70],
    [ "邵涛", 1,15, 163, 58, "滨州市",88],
    ["傅丽",1, 68,185,50,"秦皇岛市",81],
    ["宋秀兰",0,86,182, 79,"乌海市",68]
]
a = pd.DataFrame(a_values,index=[1,2,3,4,5],columns=['name','sex','age','heigh','weight','address','grade'])

a.shape
a.dtypes
a.index
a.index.values
a.index.name = 'aa'
a.values
a.columns
a.columns.values
a.columns.name = 'bb'

DataFrame原生查询方式

类列表/字典/ndarray数组的查询方式 ： 功能简陋一般用于查询单列

#查询单列，功能简陋一般用于查询单列,只能是用于查询列，切片查询行
a.name
a['name']
#查询多列
a[['name', 'address']]
a[1:4]  #，默认索引

DataFrame查询-专用查询-索引和切片
pandas专用查询方式

1. 索引
2. 切片
3. 过滤

索引和切片查询。2种查询方式

1. a.loc[行，列]，标签索引，自定义索引
2. a.iloc[行，列]，位置索引，默认索引

参数书写的顺序都是先行后列
索引查询和切片查询的区别：

1. 1.索引查询适合查询不联系行列数据
2. 2.切片查询适合查询连续的行列数据

索引查询可以实现切片查询的所有功能，只是书写效率的问题

1. 用索引查询连续的数据，需要讲每个索引都写上，效率低
2. 切片查询连续数据，只需写开始和结束索引即可，切片不能查询不连续的数据

查询时候，优先使用切片查询，无法实现功能时在使用索引

# 索引查询，用于不连续（行列有间隔）行列区块查询
# 单行查询,自定义索引查询
a.loc[2] # 简写  ,查询结果Series
a.loc[2,:]  #完整书写
# 默认索引
a.iloc[1]
a.iloc[1,:]

# 查询多行
a.loc[[2,4]]   #查询结果Dataframe
a.loc[[2,4],:]
a.iloc[[1,3]]
a.iloc[[1,3],:]

# 查询单列
a.loc[:, 'name']
a.iloc[:,0]

# 查询多列
a.loc[:,['name','address']]
a.iloc[:,[0,5]]

# 查询一行多列
a.loc[2,['name', 'address']]
a.iloc[1,[0,5]]

# 查询多行一列
a.loc[[2,4],'name']
a.iloc[[1,3],0]

# 查询单元格
a.loc[2,'address']  #效率不高,行列交叉
a.at[2,'address']    #针对单元格的特殊写法，效率更高
a.iloc[1,5]
a.iat[1,5]

# 查询多行多列
a.loc[[2,4,5],['name','address']]
a.iloc[[1,3,4],[0,5]]

# 切片查询，用于连续的行，列
# 查询单行单列
a.loc[1,:]
a.loc[:,'name']
# 多行多列
a.loc[2:4, 'name':'address'] # 自定义索引包含起始值和结束值
a.iloc[1:4,1:4]   # 默认索引包含起始值，不包含结束值

# 步长和倒查
a.loc[::2,::-1]  # ::起始值和结束值

通过值查询索引
通过布尔值过滤，帅选数据来查询

1. 1过滤查询不通过索引，而是通过值查询
2. 2用于结果索引不确定的查询
3. 3通过运算所得布尔值对查询结果进行过滤

# 类字典列表查询,使用布尔值默认查询行
a[['name','address','weight']]
a[[True,False,True,False,False]]

# 自动生成布尔
a[a['grade']<80]
a.loc[a['grade']<80]

# 布尔，索引，切片查询 ,成绩不及格的学生姓名年龄
a.loc[a['grade']<80,['name','age','grade']]

# 高于平均分的同学
a.loc[a.grade>a.grade.mean()]
a[a.grade>a.grade.mean()]
# 自动义函数  x就是外面的a传递进去的
a[lambda x : (x.grade>x.grade.mean() )& (x.sex==1)]
a.loc[lambda x : (x.grade>x.grade.mean() )& (x.sex==1),['name','sex','grade']]
# 自定义函数 x相当于a.grade
a.grade[lambda x:x<80]   

逻辑运算

1. & --->and
2. | --->or
3. - --->! not

a[(a.address == '北京海淀' )|( a.address =='美国硅谷')]
# 查询地址是北京海淀，美国硅谷
a[a['address'].isin(['北京海淀','美国硅谷'])]
a.loc[a['address'].isin(['北京海淀','美国硅谷']),['name','grade']]
# 女性 分数大于70 身高大于170
a[(a.sex == 0 )&(a.grade>70)&(a.heigh>170)]

where过滤：另外一种简洁的布尔查询法
抽出所有列组合为表格，一次判断返回结果
字符串类型不能判断
缺点：where过滤所有列的判断条件，只能有要给，使用受限制
where和mask函数，查询和替换

1. a,where(b>60,c)
2. 当判断条件True，返回a
3. 当判断条件为False，返回c

mask相反，布尔值为True的转为缺失值

#查询所有不及格的同学，并赋值为0
a.grade.where(a.grade>80,0)
# 及格返回名字，不及格返回地址
a.name.where(a.grade>80,a.address)

a.grade <70
a.grade.where(a.grade<70)  # true有值
a.grade.mask(a.grade<70)  # false有值

pandas命名

# pandas对象得命名 ，Series&DataFrame对象本身，索引都可以命名
# series得name会变成DataFrame得列索引，Series得index.name会变成DataFrame得行索引name
s = pd.Series([1,2,3,4,5], name = 'series')
s.name = 'Series'
s.index.name = 'test'
c = pd.DataFrame(s)
# dataFrame
c.index.name
c.columns.name 

for循环

for i in a:
#     print(a[i])     #显示列
#     print(a[i][3])  # 循环所以显示第3行
    for j in a[i]:
        print(j)


for index,row in a.iterrows():
#     print(index)  # 自定义得index，行索引
#     print(row)     #每行
#     print(row['name'])  #单列
    for i in row:
        print(i)    #单元格得值

　　

DataFrame数据操作　　

# 修改，先查询在修改
f.loc[2,'sex'] = 'aa'
f.loc[2,['name','sex']] = ['毛毛','female']
# 增加行
f.loc[6] = ['张三','female',18,165,67,'America',20]
# 增加列
f['qq'] = [123,456,789,112,223,445]
# 删除行
    #删除基本等同于简单版的查询
    #默认不能修改原值，只输出删除后的数据，真删除加参数inplace=TRue
    #默认的参数：axis=0删除行，axis=1删除列
f.drop(6, axis=0)
f.drop(6,inplace=True)
f.drop('name',axis=1)
f.drop(['name','address'],axis=1)