本文参照了 Pandas与SQL对比 - 简书

数据集地址:chipotle.tsv

1
2
3
4
5
6

    import pandas as pd
    file_path='chipotle.tsv'
    df=pd.read_csv(file_path,sep='\t')
    print(df.head(5))
    print(df.columns)

select

  • []获取列

    1

          df[['order_id','quantity']]

  • loc获取行获取指定index值的行

    1
2

          print(df)
      df.loc[0]

  • iloc获取行获取指定行数的行

    1
2

          print(df)
      df.iloc[0]

  • loc获取列

    1
2

          print(df)
      df.loc[:,['item_name']]

  • iloc获取列

    1
2

          print(df)
      df.iloc[:,[0]]

where,distinct,limit

  • where

    select * from df where quantity>1

    1

          df[df['quantity']>1]

  • distinct select distinct item_name from df

    1

          df['item_name'].unique()

  • limit select item_name from df limit 3

    1

          df['item_name'].head(3)

    select distinct item_name from df limit 3

    1

          df['item_name'].unique()[0:3]

order by

  • sort_values

    select * from df order by quantity

    1

          df.sort_values('quantity')

in和not in

  • isin

    select * from df where item_name in (‘Nantucket Nectar’,‘Izze’) limit 3

    1

        df['item_name'].isin(['Nantucket Nectar','Izze'])

    1

          df[df['item_name'].isin(['Nantucket Nectar','Izze'])].head(3)

    select * from df where item_name not in (‘Nantucket Nectar’,‘Izze’) limit 3

    1

          df[~df['item_name'].isin(['Nantucket Nectar','Izze'])].head(3)

group by

对应的是pandas groupby

pandas.DataFrame.groupby(by, axis, level, as_index, sort, group_keys, squeeze, observed)

  • count

    select count(1) from df group by choice_description

    1
2
3

          dd=df.groupby('choice_description').size()
      dd.values
      d2=

    1
2

          dd=df.groupby('choice_description').size()
      dd

    select choice_description,count(1) from df group by choice_description order by count(choice_description)

    1
2

          dd=df.groupby('choice_description').size().to_frame('size').reset_index().sort_values(['size'], ascending=[False])
      dd

having

  • 使用[]过滤

    select choice_description,count(1) from df group by choice_description having count(1)>300

    1
2

          dd=df.groupby('choice_description').size().to_frame('size').reset_index()
      dd[dd['size']>1]

  • filter

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

          def p_group(grouped_df,p_size):
          i=0
          for key, item in grouped_df:
            if i>p_size:
                break
            print(grouped_df.get_group(key), "\n\n")
            i=i+1

      dd=df.groupby('choice_description')
      p_group(dd,3)
      dd.filter(lambda g:g['quantity'].count()>1)

聚合函数

  • max,min,mean

    select min(quantity),max(quantity),mean(quantity),median(quantity) from df

    1

          df.agg({'quantity':['min','max','mean','median']})

top N

  • head

    先排序再取值

    1

          df.sort_values('quantity',ascending=False).head(3)

  • nlargest DataFrame.nlargest(n, columns, keep=‘first’)

    1

          df.nlargest(3,'quantity')

union

  • concat
1
2
3
4

    d1=df['item_name'].to_frame('item_name').reset_index()
    d2=df['quantity'].to_frame('quantity').reset_index()
    d3=pd.concat([d1,d2],axis=1)
    d3

join

  • merge

    pd.merge(left, right, how=‘inner’, on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=True, suffixes=('_x', ‘_y’), copy=True, indicator=False, validate=None)

    参数说明:

    left: 拼接的左侧DataFrame对象

    right: 拼接的右侧DataFrame对象

    on: 要加入的列或索引级别名称。 必须在左侧和右侧DataFrame对象中找到。 如果未传递且left_index和right_index为False，则DataFrame中的列的交集将被推断为连接键。

    left_on:左侧DataFrame中的列或索引级别用作键。 可以是列名，索引级名称，也可以是长度等于DataFrame长度的数组。

    right_on: 左侧DataFrame中的列或索引级别用作键。 可以是列名，索引级名称，也可以是长度等于DataFrame长度的数组。

    left_index: 如果为True，则使用左侧DataFrame中的索引（行标签）作为其连接键。 对于具有MultiIndex（分层）的DataFrame，级别数必须与右侧DataFrame中的连接键数相匹配。

    right_index: 与left_index功能相似。

    how: One of ‘left’, ‘right’, ‘outer’, ‘inner’. 默认inner。inner是取交集，outer取并集。比如left：[‘A’,‘B’,‘C’];right[’‘A,‘C’,‘D’]；inner取交集的话，left中出现的A会和right中出现的买一个A进行匹配拼接，如果没有是B，在right中没有匹配到，则会丢失。‘outer’取并集，出现的A会进行一一匹配，没有同时出现的会将缺失的部分添加缺失值。

    sort: 按字典顺序通过连接键对结果DataFrame进行排序。 默认为True，设置为False将在很多情况下显着提高性能。

    suffixes: 用于重叠列的字符串后缀元组。 默认为（‘x’，’ y’）。

    copy: 始终从传递的DataFrame对象复制数据（默认为True），即使不需要重建索引也是如此。

    indicator:将一列添加到名为_merge的输出DataFrame，其中包含有关每行源的信息。 _merge是分类类型，并且对于其合并键仅出现在“左”DataFrame中的观察值，取得值为left_only，对于其合并键仅出现在“右”DataFrame中的观察值为right_only，并且如果在两者中都找到观察点的合并键，则为left_only

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

          d1=pd.DataFrame({
          'name':['张三','李四'],
          'sex':[1,0]
      })

      d2=pd.DataFrame({
          'name':['张三','王五'],
          'age':[10,20]
      })

      pd.merge(d1,d2,how='left',on='name')

insert

创建新的dataframe然后将两个合并达到类似的效果

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

    d1=pd.DataFrame({
        'name':['张三','李四'],
        'sex':[1,0]
    })

    d2=pd.DataFrame({
        'name':['王五'],
        'sex':[10]
    })

    d3=pd.concat([d1,d2]).reset_index()

    d3

update

  • 使用loc

    更新指定值

    pandas.DataFrame.loc[condition, column_label] = new_value

    update d3 set sex=1 where name=‘王五’

    1
2
3

          print(d3)
      d3.loc[d3['name']=='王五','sex']=1
      d3

  • 使用iloc

    更新指定值

    1
2
3

          print(d3)
      d3.iloc[0,2]=100
      d3

  • 使用replace

    按列值更新

    df.replace([old_value], new_value)

    update d3 set sex=-1 where sex=1

    1
2
3

          print(d3)
      d3['sex']=d3['sex'].replace(1,-1)
      d3

delete

  • drop

    删除行和列

    DataFrame.drop(labels=None,axis=0, index=None, columns=None, inplace=False)

    参数说明:

    labels 就是要删除的行列的名字，用列表给定

    axis 默认为0，指删除行，因此删除columns时要指定axis=1

    index 直接指定要删除的行

    columns 直接指定要删除的列

    inplace=False，默认该删除操作不改变原数据，而是返回一个执行删除操作后的新dataframe

    inplace=True，则会直接在原数据上进行删除操作，删除后无法返回

    1
2

          print(d3)
      d3.drop(2)

    1
2

          print(d3)
      d3.drop('index',axis=1)

汇总

操作 sql pandas
查前n行 limit n head
查指定列 select 列名 loc,iloc
去重 unique distinct
条件 [df[‘列名’]>1] where
聚合 group by groupby
连接 merge join
重命名 as rename
合并 union all concat
排序 order by sort_values