pandas ---- pd.DataFrame基本用法

已于 2024-06-14 22:34:35 修改
阅读量2.8k 收藏 17
点赞数 25
分类专栏： python常用库 文章标签： pandas python
于 2024-06-14 16:41:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smalltorch/article/details/139621443
版权

文章目录

前言

本部分主要介绍一些注意事项。另外，series是基础，好多用法都是series扩展一下，很类似的。

1 loc和iloc注意事项。（后面这些都会在笔记中提到）

（1）返回的是Series还是dataframe取决于你有没有加中括号
【注】：如果你对数组索引单个也加上中括号，那么返回的将是 DataFrame 而不是 Series这个规则是普遍适用的，下面也有，这个规则要记住
【注】：单个的一般大家都习惯不加中括号，大不了最后用 .squeeze() ---- DataFrame转Series或者 .to_frame()转一下
（2）loc可以直接布尔索引，iloc布尔索引后还有.values一下转成numpy数组才能布尔索引

2 DataFrame的维度

一、 DataFrame的创建 — pd.DataFrame(data，index=None，columns=None)

— data：可以是字典、列表、NumPy 数组、Pandas Series 或 DataFrame 等。
— index：指定行索引，可以是列表、NumPy 数组或 Pandas Index 对象。
— columns：指定列名，可以是列表、NumPy 数组或 Pandas Index 对象。
没有指定就生成默认的位置索引。

1 字典创建DataFrame(字典转Dataframe很常用)

## 利用字典创建DataFrame
dict = {
   '数学':[93,89,80,77],'英语':[90,80,70,75],'语文':[87,79,67,92]}
df1 = pd.DataFrame(dict)
print(df1)                          #      数学  英语  语文
                                    #   0   93   90    87
                                    #   1   89   80    79
                                    #   2   80   70    67
                                    #   3   77   75    92

df2 =pd.DataFrame(dict,index=['张三','李四','王五','赵六'])
print(df2)                          #      数学  英语  语文
                                    # 张三   93   90    87
                                    # 李四   89   80    79
                                    # 王五   80   70    67
                                    # 赵六   77   75    92

2 用numpy数组或者嵌套list创建DataFrame

# 从列表创建
data = [['Alice', 25], 
        ['Bob', 30], 
        ['Charlie', 35]]
df1 = pd.DataFrame(data,index=['a','b','c'] ,columns=['Name', 'Age'])
print(df1)                  #       Name  Age
                            # a    Alice   25
                            # b      Bob   30
                            # c  Charlie   35

# 从 NumPy 数组创建
data = np.array([[1, 2], 
                 [3, 4], 
                 [5, 6]])
df2 = pd.DataFrame(data, index=['a','b','c'], columns=['A', 'B'])      
print(df2)                  #    A  B
                            # a  1  2
                            # b  3  4
                            # c  5  6

二、DataFrame的访问、索引、切片、布尔索引、修改等操作

1 行切片访问 df[ : ] ---- 不能用单个数字索引，只能用切片索引（后面会用loc和iloc替代这个很呆的功能）— 默认位置索引和自定义索引都支持

【注1】：这里切片就是真要切片了，不支持 df[0] , df[1]这种
【注2】：所以就很呆，所以我们后面都会用loc和iloc来替代这个垃圾功能
【注3】：切片无论是有没有设置自定义index都可以用默认位置索引（左闭右开），用自定义（符号）index也可以，但是是（左闭右闭）

# 创建一个示例 DataFrame
data = {
   
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Age': [24, 27, 22, 32, 29],
    'Score': [85.5, 88.0, 95.0, 70.5, 80.0]
}
df = pd.DataFrame(data)        #      Name  Age  Score
print(df)                      # 0    Alice   24   85.5
                               # 1      Bob   27   88.0
                               # 2  Charlie   22   95.0
                               # 3    David   32   70.5
                               # 4      Eve   29   80.0

print(df[0:3])                 #      Name  Age  Score
                               # 0    Alice   24   85.5
                               # 1      Bob   27   88.0
                               # 2  Charlie   22   95.0    
                               
df2 = pd.DataFrame(data, index=['a', 'b', 'c', 'd', 'e'])      # 自定义一下索引
print(df2)                     #       Name  Age  Score
                               # a    Alice   24   85.5
                               # b      Bob   27   88.0
                               # c  Charlie   22   95.0
                               # d    David   32   70.5
                               # e      Eve   29   80.0
                               
print(df2[0:3])                #       Name  Age  Score
                               # a    Alice   24   85.5
                               # b      Bob   27   88.0
                               # c  Charlie   22   95.0
                               
print(df2['a':'c'])            #       Name  Age  Score
                               # a    Alice   24   85.5
                               # b      Bob   27   88.0
                               # c  Charlie   22   95.0
                               
print(df2[0])              # KeyError: 0 不能用数字索引，只能用切片索引

2 按列选择

df[‘column_name’]：选择单列，返回 Series。

df[[‘column_name’]] ：选择单列，返回 DataFrame。

【注】：如果你对数组索引单个也加上中括号，那么返回的将是 DataFrame 而不是 Series这个规则是普遍适用的，下面也有，这个规则要记住
【注】：单个的一般大家都习惯不加中括号，大不了最后用 .squeeze() ---- DataFrame转Series或者 .to_frame()转一下

# 创建示例 DataFrame
data = {
   'Name': ['Alice', 'Bob', 'Charlie', 'David'],
        'Age': [24, 27, 22, 32],
        'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}
df = pd.DataFrame(data)
print(df)               #     Name  Age         City
                        # 0    Alice   24     New York
                        # 1      Bob   27  Los Angeles
                        # 2  Charlie   22      Chicago
                        # 3    David   32      Houston
                        
print(df['Name'])       # 0      Alice
                        # 1        Bob
                        # 2    Charlie
                        # 3      David
                        # Name: Name, dtype: object           Series
                        
print(df[['Name']])     #      Name
                        # 0    Alice
                        # 1      Bob
                        # 2  Charlie
                        # 3    David
                        # DataFrame                         两个中括号返回的是 DataFrame

df[[‘col1’, ‘col2’]]：选择多列，返回 DataFrame。

3 按布尔条件选择

df[df[‘column_name’] > value]：选择满足条件的行。

df[(df[‘Age’] > 25) & (df[‘Score’] > 85)] ：and 注意里面布尔条件都要分别用小括号括起来，不然会报错

df[(df[‘Age’] > 25) | (df[‘Score’] > 85)] ： or

# 创建一个示例 DataFrame
data = {
   
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Age': [24, 27, 22, 32, 29],
    'Score': [85.5, 88.0, 95.0, 70.5, 80.0]
}
df = pd.DataFrame(data)        #      Name  Age  Score
print(df)                      # 0    Alice   24   85.5
                               # 1      Bob   27   88.0
                               # 2  Charlie   22   95.0
                               # 3    David   32   70.5
                               # 4      Eve   29   80.0

print(df[(df['Age'] > 25) & (df['Score'] > 85)])        #    Name  Age  Score
                                                         # 1   Bob   27   88.0

4 loc[ ] 与 iloc[ ]进行操作

  • [注]：关于你筛选出来的数据是DataFrame还是Series关键在于你整数数组访问单个时有没有加中括号，没有加就有可能是Series，有就是DataFrame，看下面例子就懂了
  • [注]：其实这个用法记住各种筛选条件可以混合用就是了

（1）loc[ ]

loc：基于标签（名称）的索引，用于按行和列的标签来访问数据。适合于按行/列标签精确选择数据。
初始要筛选的DataFrame

# 创建示例 DataFrame
data = {
   'Name': ['Alice', 'Bob', 'Charlie', 'David'],
        'Age': [24, 27, 22, 32],
        'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}
df = pd.DataFrame(data)
df.set_index('Name', inplace=True)
print(df)                            #        Age         City
                                    # Name                      
                                    # Alice     24     New York
                                    # Bob       27  Los Angeles
                                    # Charlie   22     Chicago
                                    # David     32     Houston
基于行标签的选择 — df.loc[‘Alice’] ，df.loc[[‘Alice’]]
df.loc[‘Alice’] — 返回 Series
df.loc[[‘Alice’]] — 返回 DataFrame
df.loc[[‘Bob’, ‘David’]] — 返回 DataFrame ，这种数组的索引方式都可以用

如果你对数组索引单个也加上中括号，那么返回的将是 DataFrame 而不是 Series这个规则是普遍适用的，下面也有

# 按行标签选择
row = df.loc['Alice']               
print(row)                           # Age            24
                                    # City    New York
                                    # Name: Alice, dtype: object                # 单行返回 Series
                                
row2 = df.loc[['Alice']]                # 加上中括号，返回的是 DataFrame了·
print(row2)                         #        Age      City
                                    # Name                   
                                    # Alice     24  New York

df2 = df.loc[['Bob', 'David']]
print(df2)                           #        Age         City
                                    # Name                      
                                    # Bob       27  Los Angeles
                                    # David     32     Houston
  • 选择标签为 ‘Alice’ 的行。
基于行和列标签的选择 — df.loc[‘Alice’, ‘Age’] , df.loc[‘Alice’, [‘Age’, ‘City’]], df.loc[[‘Alice’], [‘Age’, ‘City’]]
df.loc[‘Alice’, [‘Age’, ‘City’]] — 返回Series
df.loc[[‘Alice’], [‘Age’, ‘City’]] — 返回Dataframe

如果你对数组索引单个也加上中括号，那么返回的将是 DataFrame 而不是 Series这个规则是普遍适用的，下面也有

  • 选择标签为 ‘Alice’ 的行和 ‘Age’ 列对应的单元格数据。

  • 选择标签为 ‘Alice’ 的行以及 ‘Age’ 和 ‘City’ 列。

# 选择特定行和列
value = df.loc['Alice', 'Age']       
print(value)                         # 24                                    # 如果只选择一行一列，返回的是标量

# 选择特定行的多列  --- 返回 Series
subset = df.loc['Alice', ['Age', 'City']] 
print(subset)                        # Age          24
                                    # City    New York
                                    # Name: Alice, dtype: object              # 注意：返回的是 Series
                     
# 选择特定行的多列  --- 返回 DataFrame
subset2 = df.loc[['Alice'], ['Age', 'City']] 
print(subset2)                       #        Age      City
                                    # Name                  
                                    # Alice     24  New York                      
# 如果你对数组索引单个也加上中括号，那么返回的将是 DataFrame 而不是 Series
基于行和列范围的选择（切片） — df.loc[‘Alice’:‘Charlie’, ‘Age’:‘City’]
# 选择行标签在一定范围内的多行和多列
subset = df.loc['Alice':'Charlie', 'Age':'City']
print(subset)                        #          Age         City
                                    # Name                      
                                    # Alice     24     New York
                                    # Bob       27  Los Angeles
                                    # Charlie   22     Chicago
  • 选择行标签从 ‘Alice’ 到 ‘Charlie’（包括）的行，以及从 ‘Age’ 到 ‘City’ 的列。
基于布尔条件的选择 ---- df.loc[df[‘Age’] > 25] , df.loc[df[‘Age’] > 25, [‘City’]]
  • 选择 ‘Age’ 列大于 25 的所有行。
  • 选择 ‘Age’ 列大于 25 的行，并只保留 ‘City’ 列。
subset = df.loc[df['Age'] > 25]
print(subset)                        #        Age         City
                                    # Name                      
                                    # Bob       27  Los Angeles
                                    # David     32     Houston
                                    
subset2 = df.loc[df['Age'] > 25, ['City']]
print(subset2)                      #                City
                                    # Name              
                                    # Bob   Los Angeles
                                    # David     Houston
更新操作
# 更新特定单元格的值
df.loc['Alice', 'Age'] = 30

# 更新满足条件的行的特定列
df.loc[df['Age'] > 25, 'City'] = 'San Francisco'
  • 更新 ‘Alice’ 行的 ‘Age’ 列值为 30。
  • 将 ‘Age’ 列大于 25 的所有行的 ‘City’ 列值更新为 ‘San Francisco’。

（2）iloc[ ] 的使用方法

iloc 用于通过整数位置来选择数据，类似于 NumPy 的数组索引，支持按行、按列或行列组合进行选择。iloc 方法通常有以下几种用法：
创建示例 dataframe

# 创建示例 DataFrame
data = {
   'Name': ['Alice', 'Bob', 'Charlie', 'David'],
        'Age': [24, 27, 22, 32],
        'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}
df = pd.DataFrame(data)
df.set_index('Name', inplace=True)
print(df)                            #        Age         City
                                    # Name                      
                                    # Alice     24     New York
                                    # Bob       27  Los Angeles
                                    # Charlie   22     Chicago
                                    # David     32     Houston
基于行位置的选择
df.iloc[0]
df.iloc[[0]]
df.iloc[[0,2]]
# 按行位置选择
print(df.iloc[0])             #  Age          24
                              # City    New York
                              # Name: Alice, dtype: object               # Series
                              
print(df.iloc[[0]])           #        Age      City
                              # Name                  
                              # Alice    24  New York                    # DataFrame          
                              
print(df.iloc[[0,2]])         #         Age      City
                              # Name                  
                              # Alice    24  New York
                              # Charlie  22   Chicago
基于行和列位置的选择
df.iloc[0,1] ---- 返回一个标量
df.iloc[0,[0,1]] — 返回series
df.iloc[[0],[0,1]] ---- 返回一个dataframe
print(df.iloc[0,1])                # New York
print(df.iloc[0,0])                # 24
最低0.47元/天 解锁文章
JU HE
关注
专栏目录
pd.DataFrame()函数
happy_wealthy的博客
04-21 6574
pd.DataFrame()函数 import pandas as pd import numpy as np data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'], 'year': [2000, 2001, 2002, 2001, np.nan], # np.nan表示NA 'pop': ...
pandas 数据结构--DataFrame
m0_58852358的博客
06-06 910
pandas 数据结构--DataFrame
Python中Pandas库提供的函数——pd.DataFrame的基本用法
XDXDXDXDX111的博客
10-03 1万+
DataFrame可以从各种数据源导入数据，如CSV文件、Excel表格、SQL数据库等，并且可以将数据导出为不同格式的文件。：DataFrame提供了丰富的数据操作方法，包括数据筛选、切片、合并、分组、聚合、排序等。：您可以对DataFrame进行各种数据转换操作，如数据类型转换、列重命名、数据透视表等。：DataFrame提供了处理数据中的恢复值的方法，如删除恢复值或恢复恢复值。方法来查看DataFrame的前几行数据，以了解数据的结构和内容。数据框、访问数据、进行数据操作和分析的方法和属性。
Pandas基础知识--pd.DataFrame()
最新发布
weixin_52317507的博客
09-14 1198
pd.DataFrame() 数据框 基本知识
pandas数据可视化（四）之pandas.DataFrame 操作(总结)
bluewater的专栏
04-19 8284
https://www.scipy.org/ pandas.DataFrame 创建，索引，增添，删除 - CSDN博客   https://blog.csdn.net/haruhi330/article/details/60872526 【python DataFrame】Pandas里面的屠龙宝刀DataFrame - CSDN博客  https://blog.csdn.net/u0134...
pandas中的DataFrame数据结构
Jq的博客
11-01 1523
pd.DataFrame() DataFrame 是一种二维的数据模型，相当于EXcel表格中的数据，有横竖两种坐标，横轴用columns，竖轴用index 来确定，在建立DataFrame 对象的时候，需要确定三个元素：数据，竖轴，横轴。 DataFrame既有行索引也有列索引， import pandas as pd import numpy as np a = pd.DataFrame(np.arange(16).reshape(4,4),index=list('abcd'),columns=list
Pandas的DataFrame基本使用详解
Jalen big data analysis的博客
01-04 2647
1、DataFrame类型。 2、DataFrame创建方式。 3、DataFrame相关属性。 4、DataFrame相关操作。 4.1.列操作。 4.2.行操作。 4.3.行列混合操作综合应用（重点）。 4.4.DataFrame结构。 4.5.DataFrame运算（重点）。 4.6.DataFrame排序（重点）。 4.7.DataFrame索引对象Index。 4.8.DataFrame统计相关方法(重点)。 4.9.unique 和value_counts。
pd.DataFrame用法
qq_43631083的博客
07-28 5106
无
pandas之DataFrame使用
lixiao2112924629的博客
04-15 3129
它含N个有序的列，每一列可以是不同的值类型（数值、字符串、布尔型值），也可以理解为由Series组成的字典（Pandas中用于合并数据的函数，可以沿着指定的轴将多个DataFrame或者Series对象连接起来。默认情况，可以返回指定数量的随机样本的DataFrame。numpy中数组就是类似的二维数组，可以使用行标签指定，也可以使用列标签指定。Index:表示索引值，就是行标签，默认值为0,1,2....；字典的key对应表格的列名，value对应每个列中存在的值。表示列标签，默认值为0,1,2...
PyPI 官网下载 | pandas-profiling-2.0.3.tar.gz
01-17
本文将深入探讨pandas-profiling 2.0.3版本的核心功能、安装方法以及实际应用。 一、pandas-profiling概述 pandas-profiling是一款基于Python的数据分析报告生成器，它能够自动对pandas DataFrame进行详尽的统计...
python-pd.DataFrame 总结备忘
Kukafee的博客
11-27 5082
1. 去重 对df1进行去重操作(去除完全重复的行数据)：df1 = df1.drop_duplicates() 对df1的指定若干字段去重操作：df.drop_duplicates(subset=['col_name1','col_name2'],keep='first',inplace=True) subset： 列名，可选，默认为None keep：枚举为{'first', 'last', False} 'first' - str 去重后保留第一次...
pd.dataframe.append
平平淡淡，戒急用忍，一生学闭嘴。
07-03 1403
官方文档介绍链接：append方法介绍 DataFrame.append(other, ignore_index=False, verify_integrity=False, sort=None) 功能说明：向dataframe对象中添加新的行，如果添加的列名不在dataframe对象中，将会被当作新的列进行添加 other：DataFrame、series、dict、list这样的数据结构ignore_index：默认值为False，如果为True则不使用index标签verify_integri.
pandas中DataFrame用法（python）
yourgrandfather_的博客
03-21 2925
本文主要介绍了python库中pandas的知识，承接上一篇文章，这篇文章讲解DataFrame的基本语法，索引操作，常用属性，常用方法等等。还不赶紧点进来学习。
pd.DataFrame系列
fgh123的博客
05-15 6726
pd.DataFrame初始化以及set_index import pandas as pd df = pd.DataFrame([['a1', 1], ['a2', 4]], columns=['uid', 'score']) print(df) df.set_index('uid',inplace=True); print (df)
pd.DataFrame()用法简单记录
热门推荐
Miss_leading的博客
04-19 6万+
pd.DataFrame() 先来看看它的定义： class DataFrame( data=None, index: Optional[Axes]=None, # 行标 columns: Optional[Axes]=None, # 列标 dtype: Optional[Dtype]=None, # 存储的数据类型 copy: bool=False) 我们可以直接创建空的dataframe，也可以在创造时就输入数据。 创建一个简单的dataframe： import panda
pandas之DataFrame使用详解——看完不会用你打我
xiaouncle的博客
12-22 1789
DataFrame是Pandas中的一个表格型数据结构，包含一组有序的列，每列值的类型都可不同（整型、浮点型、布尔型、字符串等），DataFrame既有行索引也有列索引，行标签index默认是序号 0,1,2我们也可以手动对其赋值
数据结构5 ：DataFrame（Pandas库）
Fwuyi的博客
03-14 4万+
series是一个一维的列数据，其中每一个元素都有一个标签。 import pandas as pd s = pd.Series([2, 4, 6, 8]) print(s) 结果为，2468为一组列数据，左边的0123是数据的对应标签。
def big_countries(world: pd.DataFrame) -> pd.DataFrame:
08-23
def big_countries(world: pd.DataFrame) -> pd.DataFrame是一个在pandas中定义的函数，它的参数是一个名为world的DataFrame。该函数的目的是过滤出符合条件的国家，并返回一个新的DataFrame，包含'name'、'population'和'area'这三列的数据。通过使用条件判断，将满足条件的行筛选出来，然后再选择所需的列返回。具体的实现方法有两种，一种是使用pandas写法，另一种是使用行过滤方法。在这两种方法中，都使用了与运算符(|)和比较运算符(>=)来对DataFrame进行条件判断，以筛选出符合条件的行。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [【Leetcode 30天Pandas挑战】学习记录 上](https://blog.csdn.net/cwtnice/article/details/132065786)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [Pandas【条件筛选】](https://blog.csdn.net/Henry_Zhao10/article/details/132050959)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值