精华内容
下载资源
问答
  • python之pandas数据筛选和csv操作
    千次阅读
    2020-12-01 16:50:47

    本博主要总结DaraFrame数据筛选方法(loc,iloc,ix,at,iat),并以操作csv文件为例进行说明

    1. 数据筛选

    a b c0 0 2 4

    1 6 8 10

    2 12 14 16

    3 18 20 22

    4 24 26 28

    5 30 32 34

    6 36 38 40

    7 42 44 46

    8 48 50 52

    9 54 56 58

    (1)单条件筛选

    df[df['a']>30]

    # 如果想筛选a列的取值大于30的记录,但是之显示满足条件的b,c列的值可以这么写

    df[['b','c']][df['a']>30]

    # 使用isin函数根据特定值筛选记录。筛选a值等于30或者54的记录

    df[df.a.isin([30, 54])]

    (2)多条件筛选

    可以使用&(并)与| (或)操作符或者特定的函数实现多条件筛选

    # 使用&筛选a列的取值大于30,b列的取值大于40的记录

    df[(df['a'] > 30) & (df['b'] > 40)]

    (3)索引筛选

    a. 切片操作

    df[行索引,列索引]或df[[列名1,列名2]]

    #使用切片操作选择特定的行

    df[1:4]

    #传入列名选择特定的列

    df[['a','c']]

    b. loc函数

    当每列已有column name时,用 df [ ‘a’ ] 就能选取出一整列数据。如果你知道column names 和index,且两者都很好输入,可以选择 .loc同时进行行列选择。

    In [28]: df.loc[0,'c']

    Out[28]: 4In [29]: df.loc[1:4,['a','c']]

    Out[29]:

    a c1 6 10

    2 12 16

    3 18 22

    4 24 28In [30]: df.loc[[1,3,5],['a','c']]

    Out[30]:

    a c1 6 10

    3 18 22

    5 30 34

    c. iloc函数

    如果column name太长,输入不方便,或者index是一列时间序列,更不好输入,那就可以选择 .iloc了,该方法接受列名的index,iloc 使得我们可以对column使用slice(切片)的方法对数据进行选取。这边的 i 我觉得代表index,比较好记点。

    In [35]: df.iloc[0,2]

    Out[35]: 4In [34]: df.iloc[1:4,[0,2]]

    Out[34]:

    a c1 6 10

    2 12 16

    3 18 22In [36]: df.iloc[[1,3,5],[0,2]]

    Out[36]:

    a c1 6 10

    3 18 22

    5 30 34In [38]: df.iloc[[1,3,5],0:2]

    Out[38]:

    a b1 6 8

    3 18 20

    5 30 32

    d. ix函数

    ix的功能更加强大,参数既可以是索引,也可以是名称,相当于,loc和iloc的合体。需要注意的是在使用的时候需要统一,在行选择时同时出现索引和名称, 同样在同行选择时同时出现索引和名称。

    df.ix[1:3,['a','b']]

    Out[41]:

    a b1 6 8

    2 12 14

    3 18 20In [42]: df.ix[[1,3,5],['a','b']]

    Out[42]:

    a b1 6 8

    3 18 20

    5 30 32In [45]: df.ix[[1,3,5],[0,2]]

    Out[45]:

    a c1 6 10

    3 18 22

    5 30 34

    e. at函数

    根据指定行index及列label,快速定位DataFrame的元素,选择列时仅支持列名。

    In [46]: df.at[3,'a']

    Out[46]: 18

    f. iat函数

    与at的功能相同,只使用索引参数

    In [49]: df.iat[3,0]

    Out[49]: 18

    2. csv操作

    csv文件内容

    Supplier Name,Invoice Number,Part Number,Cost,Purchase Date

    Supplier X,001-1001,2341,$500.00 ,1/20/14Supplier X,001-1001,2341,$500.00 ,1/20/14Supplier X,001-1001,5467,$750.00 ,1/20/14Supplier X,001-1001,5467,$750.00 ,1/20/14Supplier Y,50-9501,7009,$250.00 ,1/30/14Supplier Y,50-9501,7009,$250.00 ,1/30/14Supplier Y,50-9505,6650,$125.00 ,2002/3/14Supplier Y,50-9505,6650,$125.00 ,2002/3/14Supplier Z,920-4803,3321,$615.00 ,2002/3/14Supplier Z,920-4804,3321,$615.00 ,2002/10/14Supplier Z,920-4805,3321,$615.00 ,2/17/14Supplier Z,920-4806,3321,$615.00 ,2/24/14

    (1)csv文件读写

    import pandas aspd

    # 读写csv文件

    df= pd.read_csv("supplier_data.csv")

    df.to_csv("supplier_data_write.csv",index=None)

    (2)筛选特定的行

    #Supplier Nmae列中姓名包含'Z',或者Cost列中的值大于600

    print(df[df["Supplier Name"].str.contains('Z')])

    print(df[df['Cost'].str.strip('$').astype(float) > 600])

    print(df.loc[(df["Supplier Name"].str.contains('Z'))|(df['Cost'].str.strip('$').astype(float) > 600.0),:])

    #行中的值属于某个集合

    li= [2341,6650]

    print(df[df['Part Number'].isin(li)])

    print(df.loc[df['Part Number'].astype(int).isin(li),:])

    #行中的值匹配某个模式

    print(df[df['Invoice Number'].str.startswith("001-")])

    (3)选取特定的列

    #选取特定的列

    #列索引值,打印1,3列

    print(df.iloc[:,1:4:2])

    #列标题打印

    print(df.loc[:,["Invoice Number", "Part Number"]])

    #选取连续的行

    print(df.loc[1:4,:])

    更多相关内容
  • 主要介绍了pandas数据筛选和csv操作的实现方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 【一日一技】超简单的Pandas数据筛选方法前言一、pandas是什么?二、使用步骤1.引入库2.读入数据总结 前言 提示:这里可以添加本文要记录的大概内容: 例如:随着人工智能的不断发展,机器学习这门技术也越来越重要...

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档

    【一日一技】超简单的Pandas数据筛选方法


    前言

    提示:这里可以添加本文要记录的大概内容:

    例如:随着人工智能的不断发展,机器学习这门技术也越来越重要,很多人都开启了学习机器学习,本文就介绍了机器学习的基础内容。


    提示:以下是本篇文章正文内容,下面案例可供参考

    一、pandas是什么?

    示例:pandas 是基于NumPy 的一种工具,该工具是为了解决数据分析任务而创建的。

    二、使用步骤

    1.引入库

    代码如下(示例):

    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    import seaborn as sns
    import warnings
    warnings.filterwarnings('ignore')
    import  ssl
    ssl._create_default_https_context = ssl._create_unverified_context
    

    2.读入数据

    代码如下(示例):

    首先来定义一个DataFrame
    
    
    
    import pandas as pd
    
    datas = [
    
    {'name': '王小一', 'hight': 171, 'weight': 100},
    
    {'name': '李小二', 'hight': 163, 'weight': 200},
    
    {'name': '张小三', 'hight': 152, 'weight': 67},
    
    {'name': '郭小四', 'hight': 148, 'weight': 77},
    
    {'name': '钱小五', 'hight': 189, 'weight': 87},
    
    {'name': '孙小六', 'hight': 155, 'weight': 82},
    
    {'name': '周小七', 'hight': 169, 'weight': 74},
    
    {'name': '吴小八', 'hight': 170, 'weight': 68},
    
    {'name': '郑小九', 'hight': 173, 'weight': 65},
    
    {'name': '冯老十', 'hight': 175, 'weight': 64}
    
    ]
    
    df = pd.DataFrame(datas)
    
    
    
    运行效果图
    
    
    
    现在想要筛选hight字段大于160的所有数据
    
    
    
    代码可以这样写:
    
    df[160 < df['hight']]
    
    
    
    运行效果图
    
    
    
    现在想筛选所有 160 < hight < 170的数据
    
    
    
    如果使用Python的链式比对,就会导致报错:
    
    报错图
    
    此时,代码需要改写为很难看的一种样式:
    
    df[(160 < df['hight']) & (df['hight'] < 170)]
    
    
    
    运行效果图
    
    这样写虽然能够解决问题,但是代码可读性不好。
    
    为了提高可读性,可以使用pandas自带的.query方法。
    
    当我们要查询hight > 160的数据时,可以这样写:
    
    df.query('hight>160')
    
    
    
    运行效果图
    
    当我们要查询160 < hight < 170的时候,可以这样写:
    
    df.query('160<hight<170')
    
    
    
    运行效果图
    
    甚至还支持多个参数链式查询,例如筛选所有160<hight<170并且weight<80的数据:
    
    df.query('160<hight<170').query('weight<80')
    
    
    
    运行效果图
    
    作者:kingname
    
    排版:magic
    
    大家好,我是老表
    觉得本文不错的话,转发、留言、点赞,是对我最大的支持。
    
    每日留言
    
    说说你读完本文感受?
    
    或者一句激励自己的话?
    
    (字数不少于15字)
    
    怎么加入刻意学习队伍
    
    点我,看文末彩蛋
    
    留言有啥福利
    
    点我就知道了
    
    想进学习交流群
    
    加微信:jjxksa888
    
    备注:简说Python
    
    2小时快速掌握Python基础知识要点。
    
    完整Python基础知识要点
    
    Python小知识 | 这些技能你不会?()
    
    Python小知识 | 这些技能你不会?()
    
    Python小知识 | 这些技能你不会?()
    
    Python小知识 | 这些技能你不会?()
    
    近期推荐阅读:
    
    【1】整理了我开始分享学习笔记到现在超过250篇优质文章,涵盖数据分析、爬虫、机器学习等方面,别再说不知道该从哪开始,实战哪里找了
    
    【2】【终篇】Pandas中文官方文档:基础用法6(含1-5)
    
    觉得不错就点一下“在看”吧 
    

    该处使用的url网络请求的数据。


    总结

    提示:这里对文章进行总结:
    例如:以上就是今天要讲的内容,本文仅仅简单介绍了pandas的使用,而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。

    展开全文
  • Pandas 数据筛选,去重结合group by需求今小伙伴有一个Excel表, 是部门里的小伙9月份打卡记录, 关键字段如下:姓名, 工号, 日期, 打卡方式, 时间, 详细位置, IP地址....脱敏数据:姓名工号日期方式时间...小赵1232019-...

    Pandas 数据筛选,去重结合group by

    需求

    今小伙伴有一个Excel表, 是部门里的小伙9月份打卡记录, 关键字段如下:

    姓名, 工号, 日期, 打卡方式, 时间, 详细位置, IP地址....

    脱敏数据:

    姓名

    工号

    日期

    方式

    时间

    ...

    小赵

    123

    2019-09-01

    GPS

    08:37:50

    ....

    小赵

    123

    2019-09-01

    GPS

    18:10:50

    ...

    小陈

    124

    2019-09-01

    GPS

    08:47:30

    ...

    小陈

    124

    2019-09-01

    GPS

    15:07:50

    ...

    小陈

    124

    2019-09-01

    GPS

    18:07:5

    ...

    小赵

    123

    2019-09-02

    GPS

    08:55:50

    ...

    小李

    125

    2019-09-02

    PC

    13:10:24

    即每个小伙伴, 一个月(30天), 正常打卡是60次, 上午,下午各一次/每天. 但真实情况是: 可能忘记打卡,或者一天打了n次, 现要求是 筛选出上班迟到(9:00) 的所有人员信息.

    一看, 这用Excel, 透视一下姓名, 然后筛选日期...., 我感觉我的EXCEL水平怕是支撑不了, 但, Pandas可以呀, 5行代码搞定数据透视和条件过滤.

    核心思路:

    先按照 性别 进行分组, 然后对每组中, 日期 字段去重, 保留第一条记录即可.

    筛选出 时间 在 9:00 之后的记录, 存为Excel即可.

    完整代码如下:

    import pandas as pd

    # 1. 读取数据

    data = pd.read_excel("9月打卡记录.xlsx")

    data['时间'] = pd.to_datetime(data["时间"], format="%H:%M:%S")

    # 2. 先按姓名分组, 再对日期去重,保留第一个值

    ret = data.groupby("姓名", as_index=False).apply(lambda df:df.drop_duplicates("日期"))

    # 3. 筛选日期,并保存为excel文件

    ret[ret["时间"] >= "1900/1/1 09:00:00"].to_excel("9月迟到名单.xlsx", index=False)

    该篇的目的是为了巩固这些常用的知识点, 如 group by 结合 apply 的用法, 匿名函数, 时间字符串处理等.当然会有更复杂情况, 如分组过后, 按日期去重, 保留的第一条记录, 不是最早打卡的那条? 那这就需要写排序逻辑了, 这里只是先抛砖引玉一波.

    小结

    pandas 读取文件, pd.read_excel( ); pd.read_csv( ); pd.read_json( ); pd.read_sql_table( )...

    写入文件: pd.to_excel( ); pd.to_csv( ) ....

    字段筛选过滤等操作必须熟练.

    时间字符串 与 时间类型 的 互相转换 datetime 模块

    group by 分组聚合, agg(); apply( ), 结合Excel 透视表就很好理解

    关于映射: apply(函数名), 应用于整行or列, 对应的还有, applymap 作用每个元素, map()作用于某列Series.

    关于匿名函数lambda 的用法及与普通function的区别.

    后续还有更多工作案例分享, 基础, 高阶,都会有的.....

    python之pandas数据筛选和csv操作

    本博主要总结DaraFrame数据筛选方法(loc,iloc,ix,at,iat),并以操作csv文件为例进行说明 1. 数据筛选 a b c (1)单条件筛选 df[df[] # 如果想筛选a列的取 ...

    Pandas数据的去重,替换和离散化,异常值的检测

    数据转换 移除重复数据 import pandas as pd import numpy as np from pandas import Series data = pd.DataFrame( {' ...

    pandas的筛选功能,跟excel的筛选功能类似,但是功能更强大。

    Select rows from a DataFrame based on values in a column -pandas 筛选 https://stackoverflow.com/questi ...

    Pandas数据规整

    Pandas数据规整 数据分析和建模方面的大量编程工作都是用在数据准备上的,有时候存放在文件或数据库中的数据并不能满足数据处理应用的要求 Pandas提供了一组高级的.灵活的.高效的核心函数和算法,它 ...

    Java使用极小的内存完成对超大数据的去重计数,用于实时计算中统计UV

    Java使用极小的内存完成对超大数据的去重计数,用于实时计算中统计UV – lxw的大数据田地 http://lxw1234.com/archives/2015/09/516.htm Java使用极小 ...

    Python的工具包&lbrack;1&rsqb; -&gt&semi; pandas数据预处理 -&gt&semi; pandas 库及使用总结

    pandas数据预处理 / pandas data pre-processing 目录 关于 pandas pandas 库 pandas 基本操作 pandas 计算 pandas 的 Series ...

    使用 joblib 对 Pandas 数据进行并行处理

    使用 joblib 对 Pandas 数据进行并行处理 如果需要对一个很大的数据集进行操作,而基于一列数据生成新的一列数据可能都需要耗费很长时间. 于是可以使用 joblib 进行并行处理. 假设我们 ...

    4-Pandas之数据类型与数据筛选

    一.数据类型 1.Pandas的数据类型主要结合了pandas和numpy两个模块中的数据类型,包括以下几种: float int bool datetime64[ns]------>日期类型 ...

    pandas 数据子集的获取

    有时数据读入后并不是对整体数据进行分析,而是数据中的部分子集,例如,对于地铁乘客量可能只关心某些时间段的流量,对于商品的交易可能只需要分析某些颜色的价格变动,对于医疗诊断数据可能只对某个年龄段的人群感 ...

    随机推荐

    安装了ubuntu14&period;04&plus;windows7双系统的笔记本启动后出现grub rescue&gt&semi;提示符

    解决思想如下: 1.在grub rescue>提示符处输入ls  即可看到该命令列出了硬盘上的所有分区,找到安装了linux的分区,我的安装在(hd0,msdos8)下,所以我以(hd0,msd ...

    Ubuntu 12&period;04 LTS 及ubuntu14&period;10 -- NFS安装

    在Linux 服务器上配置好NFS 根文件系统后,在单板侧挂载NFS 文件系统,具体操作如下:ifconfig eth0 hw ether 00:10:85:18:01:84 /*配置MAC地址*/i ...

    sql reiserror 输出错误

    其语法如下: RAISERROR ( { msg_id | msg_str | @local_variable }                    { ,severity ,state }    ...

    char varchar varchar2 的区别 &lpar;转&rpar;

    char varchar varchar2 的区别       http://blog.csdn.net/honglei_zh/article/details/7172538区别:1.CHAR的长度是 ...

    集群环境下JSP中获取客户端IP地址的方法

    String ip = request.getHeader("X-Forwarded-For");if (ip == null || ip.length() == 0 || &qu ...

    《Django By Example》第十二章 中文 翻译 (个人学习,渣翻)

    书籍出处:https://www.packtpub.com/web-development/django-example 原作者:Antonio Melé (译者注:第十二章,全书最后一章,终于到这章 ...

    JPA &plus; SpringData 操作数据库原来可以这么简单 ---- 深入了解 JPA - 3

    展开全文
  • 今天聊聊Pandas数据筛选与查询的一些操作,在数据分析的过程中通常要对数据进行清洗与处理,而其中比较重要和常见的操作就有对数据进行筛选与查询。 目录: 文章目录1. 案例数据预览2. 基础操作2.1. 切片[]2.2. 索引...

    大家好,我是才哥。

    今天聊聊Pandas数据筛选与查询的一些操作,在数据分析的过程中通常要对数据进行清洗与处理,而其中比较重要和常见的操作就有对数据进行筛选与查询。

    目录:

    1. 案例数据预览

    本次案例,我们继续采用之前用到过的各地区GDP数据,数据信息大致如下,后台回复GDP可以获取哈。

    In [1]: import pandas as pd
    
    In [2]: df = pd.read_excel(r'各地区生产总值.xlsx')
    
    In [3]: df.head()
    Out[3]: 
           地区    202020192018201720160     北京市  36102.6  35445.1  33106.0  29883.0  27041.2
    1     天津市  14083.7  14055.5  13362.9  12450.6  11477.2
    2     河北省  36206.9  34978.6  32494.6  30640.8  28474.1
    3     山西省  17651.9  16961.6  15958.1  14484.3  11946.4
    4  内蒙古自治区  17359.8  17212.5  16140.8  14898.1  13789.3
    
    In [4]: df.info()
    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 32 entries, 0 to 31
    Data columns (total 6 columns):
     #   Column  Non-Null Count  Dtype  
    ---  ------  --------------  -----  
     0   地区      32 non-null     object 
     1   202031 non-null     float64
     2   201931 non-null     float64
     3   201831 non-null     float64
     4   201731 non-null     float64
     5   201631 non-null     float64
    dtypes: float64(5), object(1)
    memory usage: 1.6+ KB
    

    我们看看描述统计情况,然后在后续做筛选查询的时候好演示

    In [5]: df.describe()
    Out[5]: 
                   20202019201820172016年
    count      31.000000      31.000000     31.000000     31.000000     31.000000
    mean    32658.551613   31687.758065  29487.661290  26841.819355  24224.148387
    std     26661.811640   25848.652250  24136.181387  22161.575235  20008.278500
    min      1902.700000    1697.800000   1548.400000   1349.000000   1173.000000
    25%     13940.650000   13826.300000  13104.700000  12381.800000  11634.800000
    50%     25115.000000   24667.300000  22716.500000  20210.800000  18388.600000
    75%     42612.500000   41110.350000  37508.750000  33835.250000  30370.250000
    max    110760.900000  107986.900000  99945.200000  91648.700000  82163.200000
    

    可以看到,有效数据有30多条,为了让数据显示好一点,我们可以设置最多显示6行

    In [6]: pd.set_option('display.max_rows', 6) #最多显示6行
    
    In [7]: df
    Out[7]: 
              地区    202020192018201720160        北京市  36102.6  35445.1  33106.0  29883.0  27041.2
    1        天津市  14083.7  14055.5  13362.9  12450.6  11477.2
    2        河北省  36206.9  34978.6  32494.6  30640.8  28474.1
    ..       ...      ...      ...      ...      ...      ...
    29   宁夏回族自治区   3920.5   3748.5   3510.2   3200.3   2781.4
    30  新疆维吾尔自治区  13797.6  13597.1  12809.4  11159.9   9630.8
    31       台湾省      NaN      NaN      NaN      NaN      NaN
    
    [32 rows x 6 columns]
    

    接下来,我们开始演示数据的筛选与查询吧

    2. 基础操作

    一般来说,数据筛选有选择行、列或者指定位置的值等

    2.1. 切片[]

    切片这玩意就和python的列表数据的切片操作很相似

    选择某一列

    注意:如果列名为 2020年或者2020 年,则无法采用属性形式,因为这种操作的变量名不能以数字开头或存在空格

    df['地区']  # 切片形式
    Out[8]: 
    0          北京市
    1          天津市
    2          河北省
      
    29     宁夏回族自治区
    30    新疆维吾尔自治区
    31         台湾省
    Name: 地区, Length: 32, dtype: object
    
    In [9]: df.地区  # 属性形式
    Out[9]: 
    0          北京市
    1          天津市
    2          河北省
            ...   
    29     宁夏回族自治区
    30    新疆维吾尔自治区
    31         台湾省
    Name: 地区, Length: 32, dtype: object
    
    In [10]: # 如果列名为 2020年或者2020 年,则无法采用属性形式,因为这种操作的变量名不能以数字开头或存在空格
        ...: df.2020年
      File "C:\Users\Gdc\AppData\Local\Temp/ipykernel_6832/3948025585.py", line 2
        df.2020^
    SyntaxError: invalid syntax
    

    切片操作

    • 切片里是索引位置,筛选的是对应的行
    • 同样如果我们在切片里是列名组成的列表,则可以筛选出这些列
    • 对于只有一列的情况,切片[]是列名构成的列表返回结果类型分别是DataFrame,反之则是Series
    In [11]: df[:2] # 前两行数据
    Out[11]: 
        地区    202020192018201720160  北京市  36102.6  35445.1  33106.0  29883.0  27041.2
    1  天津市  14083.7  14055.5  13362.9  12450.6  11477.2
    
    In [12]: df[6:8] # 索引6-7 行数据(注意这里索引是从0开始的)
    Out[12]: 
         地区    202020192018201720166   吉林省  12311.3  11726.8  11253.8  10922.0  10427.0
    7  黑龙江省  13698.5  13544.4  12846.5  12313.0  11895.0
    
    In [13]: df[:16:2] # 前15行 隔2行取
    Out[13]: 
            地区    202020192018201720160      北京市  36102.6  35445.1  33106.0  29883.0  27041.2
    2      河北省  36206.9  34978.6  32494.6  30640.8  28474.1
    4   内蒙古自治区  17359.8  17212.5  16140.8  14898.1  13789.3
    ..     ...      ...      ...      ...      ...      ...
    10     浙江省  64613.3  62462.0  58002.8  52403.1  47254.0
    12     福建省  43903.9  42326.6  38687.8  33842.4  29609.4
    14     山东省  73129.0  70540.5  66648.9  63012.1  58762.5
    
    [8 rows x 6 columns]
    
    In [14]: df[::-1] # 倒序
    Out[14]: 
              地区    2020201920182017201631       台湾省      NaN      NaN      NaN      NaN      NaN
    30  新疆维吾尔自治区  13797.6  13597.1  12809.4  11159.9   9630.8
    29   宁夏回族自治区   3920.5   3748.5   3510.2   3200.3   2781.4
    ..       ...      ...      ...      ...      ...      ...
    2        河北省  36206.9  34978.6  32494.6  30640.8  28474.1
    1        天津市  14083.7  14055.5  13362.9  12450.6  11477.2
    0        北京市  36102.6  35445.1  33106.0  29883.0  27041.2
    
    [32 rows x 6 columns]
    
    In [15]: # 我们看到刚才在上述切片里是索引位置,筛选的是对应的行;同样如果我们在切片里是列名组成的列表,则可以筛选出这些列
        ...: df[['地区','2016年']]
    Out[15]: 
              地区    20160        北京市  27041.2
    1        天津市  11477.2
    2        河北省  28474.1
    ..       ...      ...
    29   宁夏回族自治区   2781.4
    30  新疆维吾尔自治区   9630.8
    31       台湾省      NaN
    
    [32 rows x 2 columns]
    
    In [16]: # 对于只有一列的情况,以下两种形式下返回结果类型分别是DataFrame和Series
        ...: df[['地区']]
    Out[16]: 
              地区
    0        北京市
    1        天津市
    2        河北省
    ..       ...
    29   宁夏回族自治区
    30  新疆维吾尔自治区
    31       台湾省
    
    [32 rows x 1 columns]
    
    In [17]: df['地区']
    Out[17]: 
    0          北京市
    1          天津市
    2          河北省
            ...   
    29     宁夏回族自治区
    30    新疆维吾尔自治区
    31         台湾省
    Name: 地区, Length: 32, dtype: object
    

    2.2. 索引选择.iloc与.loc

    按照索引有两种筛选方式,ilocloc

    • df.iloc[行表达式, 列表达式],两个表达式只支持数字切片形式:行表达式筛选行、列表达式筛选列
    • df.loc[行表达式, 列表达式],两个表达式其实是对行列索引名称的选择:行表达式筛选行、列表达式筛选列

    当然,这两种筛选方式的表达式也支持条件

    iloc[]

    大家可以根据方法名称来区分是针对自然索引位置 还是 索引名称,比如iloc多个i嘛,i就是数字码,所以它针对的是自然索引位置

    In [18]: df.iloc[0] # 返回是Series,0是自然索引位置
    Out[18]: 
    地区           北京市
    202036102.6
    201935445.1
    201833106.0
    201729883.0
    201627041.2
    Name: 0, dtype: object
    
    In [19]: df.iloc[[0]] # 返回是一行,0是自然索引位置
    Out[19]: 
        地区    202020192018201720160  北京市  36102.6  35445.1  33106.0  29883.0  27041.2
    
    In [20]: df.iloc[:2] # 前两行数据
    Out[20]: 
        地区    202020192018201720160  北京市  36102.6  35445.1  33106.0  29883.0  27041.2
    1  天津市  14083.7  14055.5  13362.9  12450.6  11477.2
    
    In [21]: df.iloc[:2,[0,1,3]] # 前两行,第0-1-3列数据
    Out[21]: 
        地区    202020180  北京市  36102.6  33106.0
    1  天津市  14083.7  13362.9
    
    In [22]: df.iloc[1,1] # 自然索引为1,第1列的数据(也就是天津2020年的gdp),一般用 .iat
    Out[22]: 14083.7
    

    loc[]

    区别于iloc,它根据索引的名称来进行筛选,如果没有设置索引一般就是自然索引

    In [23]: df1 = df.set_index('地区') # 我们设置 地区字段 列 为索引
    
    In [24]: df1
    Out[24]: 
                20202019201820172016年
    地区                                                   
    北京市       36102.6  35445.1  33106.0  29883.0  27041.2
    天津市       14083.7  14055.5  13362.9  12450.6  11477.2
    河北省       36206.9  34978.6  32494.6  30640.8  28474.1
    ...           ...      ...      ...      ...      ...
    宁夏回族自治区    3920.5   3748.5   3510.2   3200.3   2781.4
    新疆维吾尔自治区  13797.6  13597.1  12809.4  11159.9   9630.8
    台湾省           NaN      NaN      NaN      NaN      NaN
    
    [32 rows x 5 columns]
    
    In [25]: df1.loc['北京市'] # 选择 索引名为北京市的数据
    Out[25]: 
    202036102.6
    201935445.1
    201833106.0
    201729883.0
    201627041.2
    Name: 北京市, dtype: float64
    
    In [26]: df1.loc['北京市':'河北省','2020年'] # 选择 索引名称 在北京市到河北省,列名为 2020年的数据
    Out[26]: 
    地区
    北京市    36102.6
    天津市    14083.7
    河北省    36206.9
    Name: 2020, dtype: float64
    
    In [27]: df1.loc['北京市':'河北省','2019年':] # 选择 索引名称 在北京市到河北省,列名在 2019年及之后的数据
    Out[27]: 
           2019201820172016年
    地区                                     
    北京市  35445.1  33106.0  29883.0  27041.2
    天津市  14055.5  13362.9  12450.6  11477.2
    河北省  34978.6  32494.6  30640.8  28474.1
    
    In [28]: df1.loc[['北京市','上海市','重庆市','天津市'],['2020年','2019年']] # 选择索引名为 北京、上海、重庆、天津 2020年及2019年数据
    Out[28]: 
           20202019年
    地区                   
    北京市  36102.6  35445.1
    上海市  38700.6  37987.6
    重庆市  25002.8  23605.8
    天津市  14083.7  14055.5
    
    In [29]: df1.loc['北京市','2020年'] # 选择 索引名为 北京市,列名为2020年 额数据(就是坐标元素值)
    Out[29]: 36102.6
    

    2.3. 元素选择.iat与.at

    按坐标其实可以通过上述的按索引进行,这里还可以用.iat.at来实现,和按索引类型一个是自然索引值一个是索引名称

    In [30]: df.iat[0,2]
    Out[30]: 35445.1
    
    In [31]: df1.at['北京市','2019年']
    Out[31]: 35445.1
    
    In [32]: df.地区.at[3]
    Out[32]: '山西省'
    
    In [33]: # 其实还有以下方式
        ...: df1['2019年']['北京市']
    Out[33]: 35445.1
    
    In [34]: df['2019年'][0]
    Out[34]: 35445.1
    

    2.4. get与truncate

    df.get(key, default=None)类似python字典里的get方法

    df.truncate(before=None, after=None, axis=None, copy: 'bool_t' = True),返回区间数据

    get()

    对于DataFrame数据来说返回key列的值,如果key不存在就返回默认值。

    Signature: df.get(key, default=None)
    Docstring:
    Get item from object for given key (ex: DataFrame column).
    
    Returns default value if not found.
    

    对于Series数据来说,返回key索引的值,不存在就返回默认值。

    In [35]: df.get('地区','无数据')
    Out[35]: 
    0          北京市
    1          天津市
    2          河北省
            ...   
    29     宁夏回族自治区
    30    新疆维吾尔自治区
    31         台湾省
    Name: 地区, Length: 32, dtype: object
    
    In [36]: df.get('2015年','无数据')
    Out[36]: '无数据'
    
    In [37]: df.地区.get(0,'无数据')
    Out[37]: '北京市'
    
    In [38]: df.地区.get(100,'无数据')
    Out[38]: '无数据'
    

    truncate()

    将索引代入beforeafter,截取这区间的数据,支持对行和列操作

    In [39]: df.truncate(before=0,after=4)
    Out[39]: 
           地区    202020192018201720160     北京市  36102.6  35445.1  33106.0  29883.0  27041.2
    1     天津市  14083.7  14055.5  13362.9  12450.6  11477.2
    2     河北省  36206.9  34978.6  32494.6  30640.8  28474.1
    3     山西省  17651.9  16961.6  15958.1  14484.3  11946.4
    4  内蒙古自治区  17359.8  17212.5  16140.8  14898.1  13789.3
    
    In [40]: df.truncate(before='2018年',after='2020年',axis=1)
    Out[40]: 
          2020201920180   36102.6  35445.1  33106.0
    1   14083.7  14055.5  13362.9
    2   36206.9  34978.6  32494.6
    ..      ...      ...      ...
    29   3920.5   3748.5   3510.2
    30  13797.6  13597.1  12809.4
    31      NaN      NaN      NaN
    
    [32 rows x 3 columns]
    

    以上属于数据筛选与查询的基础操作,接下来我们介绍进阶操作

    3. 进阶操作

    基础操作部分我们介绍的是比较简单的数据筛选操作,实际的数据清洗与处理时我们更多的是需要根据更加复杂的组合条件来查询数据进行筛选。这一节,我们就来一一介绍一下。

    3.1. 逻辑筛选

    逻辑刷选这里是指按照一定的逻辑条件来进行数据的筛选,比如满足某条件的行、列数据等等

    In [41]: df[df['地区'] == '北京市'] # 地区是北京市的数据
    Out[41]: 
        地区    202020192018201720160  北京市  36102.6  35445.1  33106.0  29883.0  27041.2
    
    In [42]: df[df['地区'].str.contains('市')] # 地区名称 含关键字 市 的数据 
    Out[42]: 
         地区    202020192018201720160   北京市  36102.6  35445.1  33106.0  29883.0  27041.2
    1   天津市  14083.7  14055.5  13362.9  12450.6  11477.2
    8   上海市  38700.6  37987.6  36011.8  32925.0  29887.0
    21  重庆市  25002.8  23605.8  21588.8  20066.3  18023.0
    
    In [43]: df[df['地区'].str.contains('市|自治区')] # 地区名称含关键字 市或自治区 的数据
    Out[43]: 
              地区    202020192018201720160        北京市  36102.6  35445.1  33106.0  29883.0  27041.2
    1        天津市  14083.7  14055.5  13362.9  12450.6  11477.2
    4     内蒙古自治区  17359.8  17212.5  16140.8  14898.1  13789.3
    ..       ...      ...      ...      ...      ...      ...
    25     西藏自治区   1902.7   1697.8   1548.4   1349.0   1173.0
    29   宁夏回族自治区   3920.5   3748.5   3510.2   3200.3   2781.4
    30  新疆维吾尔自治区  13797.6  13597.1  12809.4  11159.9   9630.8
    
    [9 rows x 6 columns]
    
    In [44]: df[df['地区'].isin(['北京市','湖北省','江苏省'])] # 地区名称 在北京市、湖北省、江苏省的数据
    Out[44]: 
         地区     202020192018201720160   北京市   36102.6  35445.1  33106.0  29883.0  27041.2
    9   江苏省  102719.0  98656.8  93207.6  85869.8  77350.9
    16  湖北省   43443.5  45429.0  42022.0  37235.0  33353.0
    
    In [45]: df[~df['地区'].isin(['北京市','湖北省','江苏省'])] # 地区名称 不在北京市、湖北省、江苏省的数据
    Out[45]: 
              地区    202020192018201720161        天津市  14083.7  14055.5  13362.9  12450.6  11477.2
    2        河北省  36206.9  34978.6  32494.6  30640.8  28474.1
    3        山西省  17651.9  16961.6  15958.1  14484.3  11946.4
    ..       ...      ...      ...      ...      ...      ...
    29   宁夏回族自治区   3920.5   3748.5   3510.2   3200.3   2781.4
    30  新疆维吾尔自治区  13797.6  13597.1  12809.4  11159.9   9630.8
    31       台湾省      NaN      NaN      NaN      NaN      NaN
    
    [29 rows x 6 columns]
    

    除了上面用切片[]的形式,同样可以用loc[]的形式

    In [46]: df.loc[df['地区'].isin(['北京市','湖北省','江苏省'])]
    Out[46]: 
         地区     202020192018201720160   北京市   36102.6  35445.1  33106.0  29883.0  27041.2
    9   江苏省  102719.0  98656.8  93207.6  85869.8  77350.9
    16  湖北省   43443.5  45429.0  42022.0  37235.0  33353.0
    

    对于iloc[]来说,则需要是对自然索引值的判断

    In [47]: df.iloc[df.index==9]
    Out[47]: 
        地区     202020192018201720169  江苏省  102719.0  98656.8  93207.6  85869.8  77350.9
    

    我们还可以进行更复杂的逻辑判断去筛选想要的数据,在进行 或(|) 且(&) 非(~) 逻辑判断的时候,每个独立的逻辑判断需要用括号括起来

    In [48]: df[df['2020年']<df['2019年']] # 2020年GDP小于2019年GDP的省份
    Out[48]: 
         地区    2020201920182017201616  湖北省  43443.5  45429.0  42022.0  37235.0  33353.0
    
    In [49]: df[(df['2020年']>30000) &
        ...:    (df['2019年']>30000)
        ...:   ] # 最近连续2年GDP超过3万亿的地区
    Out[49]: 
         地区     202020192018201720160   北京市   36102.6   35445.1  33106.0  29883.0  27041.2
    2   河北省   36206.9   34978.6  32494.6  30640.8  28474.1
    8   上海市   38700.6   37987.6  36011.8  32925.0  29887.0
    ..  ...       ...       ...      ...      ...      ...
    17  湖南省   41781.5   39894.1  36329.7  33828.1  30853.5
    18  广东省  110760.9  107986.9  99945.2  91648.7  82163.2
    22  四川省   48598.8   46363.8  42902.1  37905.1  33138.5
    
    [13 rows x 6 columns]
    

    我们还可以通过anyall对逻辑判断后结果进行再次判断,对于all来说需要都满足才行,对于any来说只需要满足一个即可,需要注意的是默认是0列方向,1是行方向

    In [50]: df[(df[['2020年','2019年']]>30000).all(1)] # 最近连续2年GDP超过3万亿的地区
    Out[50]: 
         地区     202020192018201720160   北京市   36102.6   35445.1  33106.0  29883.0  27041.2
    2   河北省   36206.9   34978.6  32494.6  30640.8  28474.1
    8   上海市   38700.6   37987.6  36011.8  32925.0  29887.0
    ..  ...       ...       ...      ...      ...      ...
    17  湖南省   41781.5   39894.1  36329.7  33828.1  30853.5
    18  广东省  110760.9  107986.9  99945.2  91648.7  82163.2
    22  四川省   48598.8   46363.8  42902.1  37905.1  33138.5
    
    [13 rows x 6 columns]
    
    In [51]: df[(df[['2020年','2019年']]>100000).all(1)] # 最近2年有1年GDP超过10万亿
    Out[51]: 
         地区     2020201920182017201618  广东省  110760.9  107986.9  99945.2  91648.7  82163.2
    

    3.2. 函数筛选

    函数筛选是指 我们在不管是切片还是索引选择方式中,表达式还可以是lambda函数;此外,pandas也提供了一些比较函数可以用来进行数据筛选。

    自定义lambda函数

    df.loc[lambda x : x['2020年']>50000, ['地区','2020年','2019年']] # 筛选2020年GDP超过5万亿且只选 地区、2020年和2019年数据
    Out[53]: 
         地区     202020199   江苏省  102719.0   98656.8
    10  浙江省   64613.3   62462.0
    14  山东省   73129.0   70540.5
    15  河南省   54997.1   53717.8
    18  广东省  110760.9  107986.9
    
    In [54]: import re
        
    In [55]: df.loc[:, lambda x : [i for i in df.columns[1:] if int(re.findall('\d+',i)[0])<2020]] # 筛选列名满足条件的列
    Out[55]: 
          20192018201720160   35445.1  33106.0  29883.0  27041.2
    1   14055.5  13362.9  12450.6  11477.2
    2   34978.6  32494.6  30640.8  28474.1
    ..      ...      ...      ...      ...
    29   3748.5   3510.2   3200.3   2781.4
    30  13597.1  12809.4  11159.9   9630.8
    31      NaN      NaN      NaN      NaN
    
    [32 rows x 4 columns]
    

    比较函数

    panda有一些比较函数,我们可以将逻辑表达式替换为比较函数形式

    In [56]: df[df['地区'].eq('北京市')] # 等于
    Out[56]: 
        地区    202020192018201720160  北京市  36102.6  35445.1  33106.0  29883.0  27041.2
    
    In [57]: df[df['地区'].ne('北京市')] # 不等于
    Out[57]: 
              地区    202020192018201720161        天津市  14083.7  14055.5  13362.9  12450.6  11477.2
    2        河北省  36206.9  34978.6  32494.6  30640.8  28474.1
    3        山西省  17651.9  16961.6  15958.1  14484.3  11946.4
    ..       ...      ...      ...      ...      ...      ...
    29   宁夏回族自治区   3920.5   3748.5   3510.2   3200.3   2781.4
    30  新疆维吾尔自治区  13797.6  13597.1  12809.4  11159.9   9630.8
    31       台湾省      NaN      NaN      NaN      NaN      NaN
    
    [31 rows x 6 columns]
    
    In [58]: df[df['2020年'].lt(10000)] # 小于
    Out[58]: 
             地区   2020201920182017201620      海南省  5532.4  5330.8  4910.7  4497.5  4090.2
    25    西藏自治区  1902.7  1697.8  1548.4  1349.0  1173.0
    27      甘肃省  9016.7  8718.3  8104.1  7336.7  6907.9
    28      青海省  3005.9  2941.1  2748.0  2465.1  2258.2
    29  宁夏回族自治区  3920.5  3748.5  3510.2  3200.3  2781.4
    
    In [59]: df[df['2020年'].le(5532.4)] # 小于等于
    Out[59]: 
             地区   2020201920182017201620      海南省  5532.4  5330.8  4910.7  4497.5  4090.2
    25    西藏自治区  1902.7  1697.8  1548.4  1349.0  1173.0
    28      青海省  3005.9  2941.1  2748.0  2465.1  2258.2
    29  宁夏回族自治区  3920.5  3748.5  3510.2  3200.3  2781.4
    
    In [60]: df[df['2020年'].gt(50000)] # 大于
    Out[60]: 
         地区     202020192018201720169   江苏省  102719.0   98656.8  93207.6  85869.8  77350.9
    10  浙江省   64613.3   62462.0  58002.8  52403.1  47254.0
    14  山东省   73129.0   70540.5  66648.9  63012.1  58762.5
    15  河南省   54997.1   53717.8  49935.9  44824.9  40249.3
    18  广东省  110760.9  107986.9  99945.2  91648.7  82163.2
    
    In [61]: df[df['2020年'].ge(62462.0)] # 大于等于
    Out[61]: 
         地区     202020192018201720169   江苏省  102719.0   98656.8  93207.6  85869.8  77350.9
    10  浙江省   64613.3   62462.0  58002.8  52403.1  47254.0
    14  山东省   73129.0   70540.5  66648.9  63012.1  58762.5
    18  广东省  110760.9  107986.9  99945.2  91648.7  82163.2
    

    对于isin(),还可以传入字典,key为列名,value为待匹配的值(这个大家可以构建数据试试)

    3.3. query

    Signature: df.query(expr: 'str', inplace: 'bool' = False, **kwargs)
    Docstring:
    Query the columns of a DataFrame with a boolean expression.
    

    query()的很高校的查询方法,其表达式是一个字符串,我们在《》介绍过,大家可前往了解,这里稍微介绍下

    • 在引号中,如果列名是数字开头或者含有空格,则需要用`反引号标识
    • 其他情况下的列名直接写即可,用于筛选对比的对象如果是字符串则需要用引号
    • 我们还可以通过@来引入变量
    In [62]: df.query('地区=="北京市"') # 地区为北京市的数据
    Out[62]: 
        地区    202020192018201720160  北京市  36102.6  35445.1  33106.0  29883.0  27041.2
    
    In [63]: df.query('`2020年`<`2019年`') # 2020年GDP小于2019年GDP的数据
    Out[63]: 
         地区    2020201920182017201616  湖北省  43443.5  45429.0  42022.0  37235.0  33353.0
    
    In [64]: mean_gdp = df['2020年'].mean()
            
    In [64]: mean_gdp
    Out[65]: 32658.55161290323
    
    In [66]: df.query('`2020年` > @mean_gdp') # @ 引入变量
    Out[66]: 
         地区     202020192018201720160   北京市   36102.6   35445.1  33106.0  29883.0  27041.2
    2   河北省   36206.9   34978.6  32494.6  30640.8  28474.1
    8   上海市   38700.6   37987.6  36011.8  32925.0  29887.0
    ..  ...       ...       ...      ...      ...      ...
    17  湖南省   41781.5   39894.1  36329.7  33828.1  30853.5
    18  广东省  110760.9  107986.9  99945.2  91648.7  82163.2
    22  四川省   48598.8   46363.8  42902.1  37905.1  33138.5
    
    [13 rows x 6 columns]
    

    3.4. filter

    Signature:
    df.filter(
        items=None,
        like: 'str | None' = None,
        regex: 'str | None' = None,
        axis=None,
    ) -> 'FrameOrSeries'
    Docstring:
    Subset the dataframe rows or columns according to the specified index labels.
    
    Note that this routine does not filter a dataframe on its
    contents. The filter is applied to the labels of the index.
    

    df.filter()可以对行和列名进行筛选,支持模糊匹配和正则表达式

    In [67]: df.filter(items=['2020年','2016年']) # 选择两列
    Out[67]: 
          202020160   36102.6  27041.2
    1   14083.7  11477.2
    2   36206.9  28474.1
    ..      ...      ...
    29   3920.5   2781.4
    30  13797.6   9630.8
    31      NaN      NaN
    
    [32 rows x 2 columns]
    
    In [68]: df.filter(regex='年') # 列名称含 年 的列
    Out[68]: 
          202020192018201720160   36102.6  35445.1  33106.0  29883.0  27041.2
    1   14083.7  14055.5  13362.9  12450.6  11477.2
    2   36206.9  34978.6  32494.6  30640.8  28474.1
    ..      ...      ...      ...      ...      ...
    29   3920.5   3748.5   3510.2   3200.3   2781.4
    30  13797.6  13597.1  12809.4  11159.9   9630.8
    31      NaN      NaN      NaN      NaN      NaN
    
    [32 rows x 5 columns]
    
    In [69]: df1.filter(regex='市', axis=0) # 索引名含 市 的数据
    Out[69]: 
           20202019201820172016年
    地区                                              
    北京市  36102.6  35445.1  33106.0  29883.0  27041.2
    天津市  14083.7  14055.5  13362.9  12450.6  11477.2
    上海市  38700.6  37987.6  36011.8  32925.0  29887.0
    重庆市  25002.8  23605.8  21588.8  20066.3  18023.0
    
    In [70]: df1.filter(regex='^江', axis=0) # 索引名中以江开头的
    Out[70]: 
            20202019201820172016年
    地区                                               
    江苏省  102719.0  98656.8  93207.6  85869.8  77350.9
    江西省   25691.5  24667.3  22716.5  20210.8  18388.6
    
    In [71]: df1.filter(regex='自治区$', axis=0) # 索引名中以自治区结尾的
    Out[71]: 
                20202019201820172016年
    地区                                                   
    内蒙古自治区    17359.8  17212.5  16140.8  14898.1  13789.3
    广西壮族自治区   22156.7  21237.1  19627.8  17790.7  16116.6
    西藏自治区      1902.7   1697.8   1548.4   1349.0   1173.0
    宁夏回族自治区    3920.5   3748.5   3510.2   3200.3   2781.4
    新疆维吾尔自治区  13797.6  13597.1  12809.4  11159.9   9630.8
    
    In [72]: df1.filter(like='北',axis=0) # 索引名中有 北 的
    Out[72]: 
           20202019201820172016年
    地区                                              
    北京市  36102.6  35445.1  33106.0  29883.0  27041.2
    河北省  36206.9  34978.6  32494.6  30640.8  28474.1
    湖北省  43443.5  45429.0  42022.0  37235.0  33353.0
    

    以上就是本次全部内容,希望对你有所帮助,如果你喜欢的话还希望能给个在看、点个赞呀!

    加油~

    展开全文
  • 下面小编就为大家分享一篇pandas系列之DataFrame 行列数据筛选实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • df=pd.read_csv(r"C:\data\数据筛选\data1.csv",engine='python') 1.比较运算选择数据 ''' 比较运算,包含大于、小于等运算 ''' ''' 选择好评数大于17000的数据 ''' #逻辑判断+取数 print(df['好评数']>17000)#...
  • Python/Pandas筛选数据

    2021-11-21 23:02:34
    Python/Pandas筛选数据读取CSV筛选存储 读取CSV import pandas #读取大文件时,low_memory属性置为False df = pandas.read_csv('data.csv',low_memory=False) 筛选 #设置标签条件并筛选,如sales、age标签 res = ...
  • 1. 数据筛选a b c0 0 2 41 6 8 102 12 14 163 18 20 224 24 26 285 30 32 346 36 38 407 42 44 468 48 50 529 54 56 58(1)单条件筛选df[df[‘a’]>30]如果想筛选 a 列的取值大于 30 的记录, 但是之显示满足条件的...
  • pandas数据筛选 in 和 not in

    千次阅读 2020-01-06 19:37:03
    import pandas as pd data = {'city': ['Beijing', 'Shanghai', 'Guangzhou', 'Shenzhen', 'Hangzhou', 'Chongqing'], 'year': [2016, 2016, 2015, 2017, 2016, 2016], 'population': [2100,...
  • pandas实现筛选功能方式

    千次阅读 2022-03-20 08:32:18
    pandas实现筛选功能方式
  • 我们首先构造了一个 5X4 的矩阵数据。 import pandas as pd import numpy as np dates = pd.date_range('20200315', periods = 5) df = pd.DataFrame(np.arange(20).reshape(5,4), index = dates, columns = ['A', '...
  • 数据筛选背景在处理数据时,我们可能希望从数据库里面筛选出符合特定条件的记录(个案或样本,...如下图所示:excel数据筛选pandas处理正确代码#加载库import pandas as pdimport numpy as np#读取数据data=pd.rea...
  • Python Pandas数据筛选方法汇总

    千次阅读 2020-05-19 20:48:24
    Pandas数据筛选一、准备数据二、通过逻辑规则筛选(大于/小于等)三、删除重复元素三、显示最前面 / 最后面的 n 行3.1 显示前面 n 行3.2 显示后面 n 行四、随机抽取4.1 随机抽取一定比例4.2 随机抽取 n 行五、...
  • 下面小编就为大家分享一篇pandas按若干个列的组合条件筛选数据的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 数据筛选 第一步数据标记 标记数据非常简单, 直接获取数据然后进行判断即可 bools = df['value'] > 100 # 在这段代码中, 获取数据中 'value' 这一列 # 然后大于100 是筛选条件, 那么他就会返回一个布尔值 # 如果...
  • pandas按条件筛选数据

    万次阅读 多人点赞 2019-04-08 19:39:58
    pandas中对DataFrame筛选数据的方法有很多的,以后会后续进行补充,这里只整理遇到错误的情况。 1.使用布尔型DataFrame对数据进行筛选 使用一个条件对数据进行筛选,代码类似如下: num_red=flags[flags['red']=...
  • 目录数据初始化选择某一行通过loc选择某一行通过iloc选择某一行选择某一列最简单的方法...import pandas as pd import numpy as np a=np.array([['北京','北方','一线','非沿海'],['杭州','南方','二线','非沿海'],
  • 主要介绍了pandas数据处理基础之筛选指定行或者指定列的数据的相关资料,需要的朋友可以参考下
  • 1、数据筛选
  • Pandas筛选操作详解

    2020-11-29 11:51:50
    在数据处理过程中,经常会遇到要筛选不同要求的数据,通过 Pandas 可以轻松时间,这一篇我们来看下如何使用 Pandas 来完成数据筛选吧。# 导入相关库import numpy as npimport pandas as pdPandas 中除了支持 Python ...
  • Python pandas 根据指定条件筛选数据

    千次阅读 2021-03-16 14:15:56
    1、构造dataframe import pandas as pd ...2、筛选出"sh"列大于5的数据 法一:直接筛选,适用于一些比较简单直接的筛选,这种方式方便快捷。 df[df["sh"]>5] 法二:函数筛选,适用于比较复杂的条件筛选,函
  • Pandas:关于pandas筛选的效率测试

    千次阅读 2020-08-09 08:55:05
    比如给出一个切分好的地址列表,如[‘福建省’, ‘厦门市’, ‘思明区’, ‘梧村街道’, ‘湖滨南路’],需要将这个地址在140+万条数据的地址库里筛选出满足条件的所有地址,应该怎么做呢? 一、常规方法 最常规的...
  • 主要介绍了使用Pandas数据进行筛选和排序的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • pandas使用与、或、非对dataframe的数据进行筛选(与关系数据筛选、或关系数据筛选、非关系数据筛选)
  • 今天小编就为大家分享一篇浅谈pandas筛选出表中满足另一个表所有条件的数据方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,177
精华内容 8,470
关键字:

pandas数据筛选