首页 > 其他分享 >Pandas学习笔记之Dataframe

Pandas学习笔记之Dataframe

时间：2023-07-26 11:57:16浏览次数：32  
标签：index df df1 笔记 Dataframe pd print Pandas columns

一、Dataframe基本概念

# 二维数组"Dataframe：是一个表格型的数据结构，包含一组有序的列，其列的值类型可以是数值、字符串、布尔值等。
data = {'name': ['Jack', 'Tom', 'Mary'],
        'age': [18, 19, 20],
        'gender': ['m', 'm', 'w']}
# Dataframe中的数据以一个或多个二维块存放，不是列表、字典或一维数组结构。
# Dataframe是一个表格型的数据结构，“带有标签的二维数组”。
# Dataframe带有index（行标签）和columns（列标签）
frame = pd.DataFrame(data)
# 查看数据，数据类型为dataframe
print(frame)
print(type(frame))
# .index查看行标签
print(frame.index, '\n该数据类型为：', type(frame.index))
# .columns查看列标签
print(frame.columns, '\n该数据类型为：', type(frame.columns))
# .values查看值，数据类型为ndarray
print(frame.values, '\n该数据类型为：', type(frame.values))

二、创建方法

1. 数组/list组成的字典

# Dataframe 创建方法一：由数组/list组成的字典
# 创建方法:pandas.Dataframe()

data1 = {'a':[1,2,3],
        'b':[3,4,5],
        'c':[5,6,7]}
data2 = {'one':np.random.rand(3),
        'two':np.random.rand(3)}   # 这里如果尝试  'two':np.random.rand(4) 会怎么样？

# 由数组/list组成的字典 创建Dataframe，columns为字典key，index为默认数字标签
# 字典的值的长度必须保持一致！
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)
print(df1)
print(df2)
print('='*50)


# columns参数：可以重新指定列的顺序，格式为list，如果现有数据中没有该列（比如'd'），则产生NaN值
# 如果columns重新指定时候，列的数量可以少于原数据
df1 = pd.DataFrame(data1, columns = ['b','c','a','d'])
#df1 = pd.DataFrame(data1, columns = ['b','c'])


# index参数：重新定义index，格式为list，长度必须保持一致
df2 = pd.DataFrame(data2, index = ['f1','f2','f3'])  # 这里如果尝试  index = ['f1','f2','f3','f4'] 会怎么样？
print(df2)

2.Series组成的字典

# 由Seris组成的字典 创建Dataframe，columns为字典key，index为Series的标签（如果Series没有指定标签，则是默认数字标签）
# Series可以长度不一样，生成的Dataframe会出现NaN值
data1 = {'one':pd.Series(np.random.rand(2)),
        'two':pd.Series(np.random.rand(3))}  # 没有设置index的Series
data2 = {'one':pd.Series(np.random.rand(2), index = ['a','b']),
        'two':pd.Series(np.random.rand(3),index = ['a','b','c'])}  # 设置了index的Series


df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)
print(df1,'\n')
print(df2)

3.通过二维数组直接创建 

# Dataframe 创建方法三：通过二维数组直接创建
# 通过二维数组直接创建Dataframe，得到一样形状的结果数据，如果不指定index和columns，两者均返回默认数字格式
ar = np.random.rand(9).reshape(3,3)
df1 = pd.DataFrame(ar)
# index和colunms指定长度与原数组保持一致
df2 = pd.DataFrame(ar, index = ['a', 'b', 'c'], columns = ['one','two','three'])  # 可以尝试一下index或columns长度不等于已有数组的情况
print(df1,'\n')
print(df2)

4.字典组成的列表

data = [{'one': 1, 'two': 2}, {'one': 5, 'two': 10, 'three': 20}]
df1 = pd.DataFrame(data)
# 由字典组成的列表创建Dataframe，columns为字典的key，index不做指定则为默认数组标签
# colunms和index参数分别重新指定相应列及行标签
df2 = pd.DataFrame(data, index = ['a','b'])
df3 = pd.DataFrame(data, columns = ['one','two'])
print(df1,'\n')
print(df2,'\n')
print(df3)

5.由字典组成的字典

data = {'Jack':{'math':90,'english':89,'art':78},
       'Marry':{'math':82,'english':95,'art':92},
       'Tom':{'math':78,'english':67}}
df1 = pd.DataFrame(data)
# 由字典组成的字典创建Dataframe，columns为字典的key，index为子字典的key
print(df1,'\n')

# columns参数可以增加和减少现有列，如出现新的列，值为NaN
# index在这里和之前不同，并不能改变原有index，如果指向新的标签，值为NaN （非常重要！）
df2 = pd.DataFrame(data, columns = ['Jack','Tom','Bob'])
df3 = pd.DataFrame(data, index = ['a','b','c'])
print(df2,'\n')
print(df3)

三、Dataframe索引 

Dataframe既有行索引也有列索引，可以被看做由Series组成的字典（共用一个索引）

1.选择行与列

df = pd.DataFrame(np.random.rand(12).reshape(3,4)*100,
                   index = ['one','two','three'],
                   columns = ['a','b','c','d'])
print(df,'\n')

# 按照列名选择列，只选择一列输出Series，选择多列输出Dataframe
data1 = df['a']
data2 = df[['a','c']]
print(data1,type(data1),'\n')
print(data2,type(data2),'\n')
print('='*50)


# 按照index选择行，只选择一行输出Series，选择多行输出Dataframe
data3 = df.loc['one']
data4 = df.loc[['one','two']]
print(data3,type(data3),'\n')
print(data4,type(data4))

2.选择列

# df[] - 选择列
# 一般用于选择列，也可以选择行

df = pd.DataFrame(np.random.rand(12).reshape(3,4)*100,
                   index = ['one','two','three'],
                   columns = ['a','b','c','d'])
print(df)
print('='*50)

# df[]默认选择列，[]中写列名（所以一般数据colunms都会单独制定，不会用默认数字列名，以免和index冲突）
# 单选列为Series，print结果为Series格式
# 多选列为Dataframe，print结果为Dataframe格式
data1 = df['a']
data2 = df[['b','c']]  # 尝试输入 data2 = df[['b','c','e']]
print(data1,'\n')
print(data2,'\n')
print('='*50)


# df[]中为数字时，默认选择行，且只能进行切片的选择，不能单独选择（df[0]）
# 输出结果为Dataframe，即便只选择一行
# df[]不能通过索引标签名来选择行(df['one'])
# 核心笔记：df[col]一般用于选择列，[]中写列名
data3 = df[:1]
#data3 = df[0]
#data3 = df['one']
print(data3,type(data3))

3.按index选择行

# df.loc[] - 按index选择行
# 核心笔记：df.loc[label]主要针对index选择行，同时支持指定index，及默认数字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('='*50)

# 单个标签索引，返回Series
data1 = df1.loc['one']
data2 = df2.loc[1]
print(data1,'\n')
print(data2,'\n')
print('='*50)

# 多个标签索引，如果标签不存在，则返回NaN
# 顺序可变
data3 = df1.loc[['two','three','four']]
data4 = df2.loc[[3,2,1]]
print(data3,'\n')
print(data4,'\n')
print('='*50)

# 切片索引 可以做切片对象
# 末端包含
data5 = df1.loc['one':'three']
data6 = df2.loc[1:3]
print(data5,'\n')
print(data6)

4.按照整数位置（从轴的0到length-1）选择行 

# df.iloc[] - 按照整数位置（从轴的0到length-1）选择行
# 类似list的索引，其顺序就是dataframe的整数位置，从0开始计

df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                   index = ['one','two','three','four'],
                   columns = ['a','b','c','d'])
print(df)
print('='*50)

# 单位置索引
# 和loc索引不同，不能索引超出数据行数的整数位置
print('单位置索引')
print(df.iloc[0],'\n')
print(df.iloc[-1],'\n')
#print(df.iloc[4])


# 多位置索引 顺序可变
print('多位置索引')
print(df.iloc[[0,2]],'\n')
print(df.iloc[[3,2,1]],'\n')


# 切片索引
# 末端不包含
print('切片索引')
print(df.iloc[1:3],'\n')
print(df.iloc[::2])

5.布尔型索引

# 布尔型索引
# 和Series原理相同

df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                   index = ['one','two','three','four'],
                   columns = ['a','b','c','d'])
print(df)
print('='*50)

# 不做索引则会对数据每个值进行判断
# 索引结果保留 所有数据：True返回原数据，False返回值为NaN
b1 = df < 20
print(b1,type(b1),'\n')
print(df[b1],'\n')  # 也可以书写为 df[df < 20]
print('='*50)

# 单列做判断
# 索引结果保留 单列判断为True的行数据，包括其他列
b2 = df['a'] > 50
print(b2,type(b2),'\n')
print(df[b2],'\n')  # 也可以书写为 df[df['a'] > 50]
print('='*50)

# 多列做判断
# 索引结果保留 所有数据：True返回原数据，False返回值为NaN
b3 = df[['a','b']] > 50
print(b3,type(b3),'\n')
print(df[b3],'\n')  # 也可以书写为 df[df[['a','b']] > 50]
print('='*50)

# 多行做判断
# 索引结果保留 所有数据：True返回原数据，False返回值为NaN
b4 = df.loc[['one','three']] < 50
print(b4,type(b4),'\n')
print(df[b4])  # 也可以书写为 df[df.loc[['one','three']] < 50]

6.多重索引 

# 多重索引：比如同时索引行和列
# 先选择列再选择行 —— 相当于对于一个数据，先筛选字段，再选择数据量

df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                   index = ['one','two','three','four'],
                   columns = ['a','b','c','d'])
print(df)
print('='*50)

print(df['a'].loc[['one','three']],'\n')   # 选择a列的one，three行
print(df[['b','c','d']].iloc[::2],'\n')   # 选择b，c，d列的one，three行
print(df[df['a'] < 50].iloc[:2])   # 选择满足判断索引的前两行数据

四、Dataframe基本操作

1.数据查看、转置 

2.添加、修改、删除值 

df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                   columns = ['a','b','c','d'])
print(df,'\n')

# 新增列/行并赋值
print('='*15,"新增列",'='*15,)
df['e'] = 10
df.loc[4] = 20
print(df,'\n')

# 索引后直接修改值
print('='*15,"修改列",'='*15,)
df['e'] = 20
df[['a','c']] = 100
print(df,'\n')



# 删除  del / drop()
print('='*15,"del删除列",'='*15,)
df1 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                   columns = ['a','b','c','d'])
print(df1,'\n')

# del语句 - 删除列
del df1['a']
print(df1,'\n')
print('-----')

print('='*15,"新drop删除列",'='*15,)
# drop()删除行，inplace=False → 删除后生成新的数据，不改变原数据
print(df1.drop(0),'\n')
print(df1.drop([1,2]),'\n')
print(df1)
print('-----')


# drop()删除列，需要加上axis = 1，inplace=False → 删除后生成新的数据，不改变原数据
print(df1.drop(['d'], axis = 1),'\n')
print(df1)

3.对齐 

# 对齐
# DataFrame对象之间的数据自动按照列和索引（行标签）对齐
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'])
print(df1 + df2)

4.按值排序

# 排序1 - 按值排序 .sort_values
# 同样适用于Series

df1 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
                   columns = ['a','b','c','d'])
print(df1,'\n')

# 单列排序
# ascending参数：设置升序降序，默认升序
print('='*15,"单例排序",'='*15,)
print(df1.sort_values(['a'], ascending = True),'\n')  # 升序
print(df1.sort_values(['a'], ascending = False),'\n')  # 降序


# 多列排序，按列顺序排序
print('='*15,"多列排序",'='*15,)
df2 = pd.DataFrame({'a':[1,1,1,1,2,2,2,2],
                  'b':list(range(8)),
                  'c':list(range(8,0,-1))})
print(df2,'\n')
print(df2.sort_values(['a','c']))

5.索引排序

#print('='*15,"del删除列",'='*15,)
# 排序2 - 索引排序 .sort_index
# 按照index排序
# 默认 ascending=True, inplace=False
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 = ['h','s','x','g'],
                   columns = ['a','b','c','d'])
print(df1,'\n')
print(df1.sort_index(),'\n')
print(df2,'\n')
print(df2.sort_index())

 

 

标签：index,df,df1,笔记,Dataframe,pd,print,Pandas,columns
From： https://www.cnblogs.com/panwenbin-logs/p/17582077.html

相关文章

  • java笔记_11_JVM调优参数(转载）
    -Xms2048m//设置jvm的初始内存。这个值最好设置的跟-Xmx相同，以避免每次垃圾回收完成后JVM都要重新分配内存-Xmx2048m//JVM最大可用内存-XX:PermSize=256M//设置持久代大小-XX:MaxPermSize=512M//设置最大持久代大小-XX:+PrintGCDetails-XX:+PrintGCDat......
  • Pandas学习笔记之Series
    一、Series基本概念及创建1.基本概念#Series数据结构#Series是带有标签的一维数组，可以保存任何数据类型（整数，字符串，浮点数，Python对象等）,轴标签统称为索引#导入numpy、pandas模块importnumpyasnpimportpandasaspds=pd.Series(np.random.rand(5))print(s)#......
  • 013 学习笔记--锁
    锁：全局锁：锁定数据库中的所有表表级锁：每次操作锁住整张表行级锁：每次操作锁住对应的行数据1.概述锁是计算机协调多个进程或线程并发访问某一资源的机制。在数据库中，除传统的计算资源(CUP、RAM、IO)的争用以外，数据也是一种供许多用户共享的资源。如何保证数据并发访问的一致性......
  • Qt+GDAL开发笔记（一）：在windows系统mingw32编译GDAL库、搭建开发环境和基础Demo
    前言  麒麟系统上做全球北斗定位终端开发，调试工具要做一个windows版本方便校对，北斗GPS发过来的是大地坐标，应用需要的是经纬度坐标，所以需要转换，可以使用公式转换，但是之前涉及到了另一个shang市公司项目使用WG，最终选择了GDAL库进行转换。注意  如果读者不强制要求ming......
  • (笔记)电流趋肤效应原理
     趋肤效应的原因非常简单：电流总是沿着阻抗低的方向分布。好比一条河流，沿着河流正中间有一大块石头，那么原本需要从中间流过的一部分水就会被挤到了旁边。我们首先需要明确一点，如果考虑单独的一个导体：其阻抗并非只有导体的电阻，而是由电阻，感抗构成的；——“容抗”需要......
  • 【学习笔记】树状数组
    树状数组是一种数据结构，普通树状数组维护的信息及运算要满足结合律且可差分。单点加、区间求和树状数组是用长度为\(n\)的数组存储的。我们假设这个数组为\(n\)，令lowbit(i)=i&(-i)，则\(c_i\)保存的是向前lowbit(i)长度的\(a\)数组区间和。单点加：从\(i\)开始，修改所......
  • 【学习笔记】单调队列和单调栈
    单调栈以这道题为例：P5788。我们考虑维护一个单调栈，里面存的是下标，使里面的下标对应的元素从栈顶到栈底是单调上升的。我们从\(n\rightarrow1\)枚举\(a_i\)对于每个\(i\)，如果栈非空，令栈顶的下标为\(j\)，若\(a_j\)不比\(a_i\)大，那么这个栈顶元素由于值又小，位置又靠后，如......
  • 【学习笔记】并查集
    先来看百度百科上的定义：并查集，在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。并查集是一种树型的数据结构，用于处理一些不相交集合（disjointsets）的合......
  • 7.24 树上问题2笔记
    题单T1题目•有一棵点数为\(n\)的树。•有\(q\)次询问，每次询问有多少个点到\(a,b\)距离相等。•\(1≤n\),\(q≤500000\)。Solution•设询问\(a,b\)两点直接的路长度为\(d\)。•如果\(d\)为奇数，那么无解，\(d\)为偶数有解。•考虑以下几种情况：\(......
  • 7.23 树上问题笔记
    题单由于题目过多，只放几道重要的。。。T1题目•A国有\(n\)座城市，编号从\(1\)到\(n\)，城市之间有\(m\)条双向道路。每一条道路对车辆都有重量限制\(z\)，简称限重。•现在有\(q\)辆货车在运输货物，司机们想知道每辆车在不超过车辆限重的情况下，最多能运多重的货物。......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99