python积累--pandas读取数据积累--dataframe用法_用pandas将酒类消费数据表中数据读取为dataframe

通过带有标签的列和索引，Pandas 使我们可以以一种所有人都能理解的方式来处理数据。它可以让我们毫不费力地从诸如 csv 类型的文件中导入数据。我们可以用它快速地对数据进行复杂的转换和过滤等操作。

pandas和 Numpy、Matplotlib 一起构成了一个 Python 数据探索和分析的强大基础。Scipy是同类型的库，感兴趣的可以进行了解。

本文记录和收集积累pandas的用法。

导入 Pandas

import pandas as pd # This is the standard
1

这是导入 pandas 的标准方法。我们不想一直写 pandas 的全名，但是保证代码的简洁和避免命名冲突都很重要，所以折中使用 pd 。如果你去看别人使用 pandas 的代码，就会看到这种导入方式。

Pandas 中的数据类型

Pandas 基于两种数据类型，series 和 dataframe。

series 是一种一维的数据类型，其中的每个元素都有各自的标签。你可以把它当作一个由带标签的元素组成的 numpy 数组。标签可以是数字或者字符。 通俗的理解就是 带有标签的行 或者带有标签的列。

dataframe 是一个二维的、表格型的数据结构。Pandas 的 dataframe 可以储存许多不同类型的数据，并且每个轴都有标签。你可以把它当作一个 series 的字典。通俗的理解就是 行列带有标签的表格。

将数据导入 Pandas

# Reading a csv into Pandas.
df = pd.read_csv('my_data.csv', header=0)
1
2

如果你的数据集中有中文的话，最好在里面加上 encoding = ‘gbk’ ，以避免乱码问题。后面的导出数据的时候也一样。

这里我们从 csv 文件里导入了数据，并储存在 dataframe 中。这一步非常简单，你只需要调用 read_csv 然后将文件的路径传进去就行了。header 关键字告诉 Pandas 哪些是数据的列名。如果没有列名的话就将它设定为 None 。

查看前 x 行的数据

# Getting first x rows.
df.head(5)
1
2

我们只需要调用 head() 函数并且将想要查看的行数传入。

查看某列所有的值

df[column].unique()
1

查看后 x 行的数据

# Getting last x rows.
df.tail(5)
1
2

跟 head 一样，我们只需要调用 tail 并且传入想要查看的行数即可。注意，它并不是从最后一行倒着显示的，而是按照数据原来的顺序显示。

修改列名

输入新列名即可

# Changing column labels.
df.columns = ['water_year','rain_octsep', 'outflow_octsep',
              'rain_decfeb', 'outflow_decfeb', 'rain_junaug', 'outflow_junaug']
1
2
3

选取 指定的列

final_result= tree_have_mbarcode_wbarcode_manwife_wifeman[['r_id','source','man','wife','relation']]
1

查询总行数

在 Pandas 中，一条记录对应着一行，所以我们可以对数据集调用 len 方法，它将返回数据集的总行数：

# Finding out how many rows dataset has.
len(df)
1
2

上面的代码返回一个表示数据行数的整数

统计表格

你可能还想知道数据集的一些基本的统计数据，在 Pandas 中，这个操作简单到哭：

# Finding out basic statistical information on your dataset.
pd.options.display.float_format = '{:,.3f}'.format # Limit output to 3 decimal places.
df.describe()
1
2
3

这将返回一张表，其中有诸如总数、均值、标准差之类的统计数据：

提取一整列

使用列的标签可以非常简单地做到：

# Getting a column by label
df['rain_octsep']
1
2

注意，当我们提取列的时候，会得到一个 series ，而不是 dataframe 。记得我们前面提到过，你可以把 dataframe 看作是一个 series 的字典，所以在抽取列的时候，我们就会得到一个 series。

使用点号获取列

访问对象属性一样访问数据集的列——只用一个点号。

# Getting a column by label using .
df.rain_octsep
1
2

这句代码返回的结果与前一个例子完全一样——是我们选择的那列数据。

返回列是否符合条件

pandas可以使用布尔过滤（boolean masking）的技术，通过在一个数组上运行条件来得到一个布林数组。

# Creating a series of booleans based on a conditional
df.rain_octsep < 1000 # Or df['rain_octsep] < 1000
1
2

上面的代码将会返回一个由布尔值构成的 dataframe。True 表示在十月-九月降雨量小于 1000 mm，False 表示大于等于 1000 mm。

我们可以用这些条件表达式来过滤现有的 dataframe。

筛选符合条件的列

# Using a series of booleans to filter
df[df.rain_octsep < 1000]
1
2

这条代码只返回十月-九月降雨量小于 1000 mm 的记录：

也可以通过复合条件表达式来进行过滤：

# Filtering by multiple conditionals
df[(df.rain_octsep < 1000) & (df.outflow_octsep < 4000)] # Can't use the keyword 'and'
1
2

这条代码只会返回 rain_octsep 中小于 1000 的和 outflow_octsep 中小于 4000 的记录：

注意重要的一点：这里不能用 and 关键字，因为会引发操作顺序的问题。必须用 & 和圆括号。

和操作 使用&、或操作使用|、not操作使用 ~

    df = df[(df['user:Name'].str.find('condor')>=0) | (df['UsageType'].str.find('CNW1-SpotUsage:c4.8xlarge')>=0)]
1

列筛选–字符串匹配–包含等

如果你的数据是字符串，你也可以使用字符串方法来进行过滤：

# Filtering by string methods
df[df.water_year.str.startswith('199')]
1
2

注意，你必须用 .str.[string method] ，而不能直接在字符串上调用字符方法。上面的代码返回所有 90 年代的记录。

行选择的前提—设置索引

可以设置一个（或者多个）新的索引：

# Setting a new index from an existing column
df = df.set_index(['water_year'])
df.head(5)
1
2
3

上面的代码将 water_year 列设置为索引。注意，列的名字实际上是一个列表，虽然上面的例子中只有一个元素。如果你想设置多个索引，只需要在列表中加入列的名字即可。

数字型的标签–行选择–iloc

之前的部分展示了如何通过列操作来得到数据，但是 Pandas 的行也有标签。行标签可以是基于数字的或者是标签，而且获取行数据的方法也根据标签的类型各有不同。

如果你的行标签是数字型的，你可以通过 iloc 来引用：

# Getting a row via a numerical index
df.iloc[30]
1
2

iloc 只对数字型的标签有用。它会返回给定行的 series，行中的每一列都是返回 series 的一个元素。

字符型的标签–行选择–loc

我们设置的索引列中都是字符型数据，这意味着我们不能继续使用 iloc 来引用，那我们用什么呢？用 loc 。

# Getting a row via a label-based index
df.loc['2000/01']
1
2

和 iloc 一样，loc 会返回你查询的行，唯一一点不同就是此时你使用的是基于字符串的引用，而不是基于数字的。

字符型和数字类型的标签–行选择–ix

还有一个引用列的常用常用方法—— ix 。如果 loc 是基于标签的，而 iloc 是基于数字的，那 ix 是基于什么的？事实上，ix 是基于标签的查询方法，但它同时也支持数字型索引作为备选。

# Getting a row via a label-based or numerical index
df.ix['1999/00'] # Label based with numerical index fallback *Not recommended
1
2

与 iloc、loc 一样，它也会返回你查询的行。

如果 ix 可以同时起到 loc 和 iloc 的作用，那为什么还要用后两个？一大原因就是 ix 具有轻微的不可预测性。还记得我说过它所支持的数字型索引只是备选吗？这一特性可能会导致 ix 产生一些奇怪的结果，比如讲一个数字解释为一个位置。而使用 iloc 和 loc 会很安全、可预测并且让人放心。但是我要指出的是，ix 比 iloc 和 loc 要快一些。

选取等于某些值的行记录

用 ==

df.loc[df['column_name'] == some_value]
1

选取某列是否需要的数值 用 isin

df.loc[df['column_name'].isin(some_values)]
1

多种条件的选取 用 &

df.loc[(df['column'] == some_value) & df['other_column'].isin(some_values)]

1
2

选取不等于某些值的行记录 用 ！=

df.loc[df['column_name'] != some_value]
1

isin返回一系列的数值,如果要选择不符合这个条件的数值使用~

df.loc[~df['column_name'].isin(some_values)]
1

按位置选择

更多按位置选择内容：http://pandas.pydata.org/pandas-docs/version/0.20/indexing.html#indexing-integer

通过传递的整数的位置进行选择：

df.iloc[3] #取出第三行
Clipboard Image.png
1
2

通过整数切片，类似于numpy / python：

df.iloc[3:5,0:2]
Clipboard Image.png
1
2

切出3-4行，1-2列一块区域

通过整数位置列表切分，类似numpy的/ Python的风格：

df.iloc[[1,2,4],[0,2]]
1

切分出某些行：

df.iloc[1:3,:]
1

切分出某些列：

df.iloc[:,1:3]
1

获取某个值

df.iloc[1,1]
1

快速访问某个值（等同于先前的方法）：

df.iat[1,1]
1

一个dataframe拆分成多个

df = pd.read_csv('data/tgnb_merge.csv', encoding='utf-8')
# df.drop_duplicates(keep='first', inplace=True)  # 去重，只保留第一次出现的样本
df = df.sample(frac=1.0)  # 全部打乱
cut_idx = int(round(0.1 * df.shape[0]))
df_test, df_train = df.iloc[:cut_idx], df.iloc[cut_idx:]
print df.shape, df_test.shape, df_train.shape  # (3184, 12) (318, 12) (2866, 12)
1
2
3
4
5
6

合并连接多个dataframe

df1=DataFrame(np.random.randn(3,4),columns=['a','b','c','d'])  
  
df2=DataFrame(np.random.randn(2,3),columns=['b','d','a'])  
  
pd.concat([df1,df2])  
  
          a         b         c         d  
0 -0.848557 -1.163877 -0.306148 -1.163944  
1  1.358759  1.159369 -0.532110  2.183934  
2  0.532117  0.788350  0.703752 -2.620643  
0 -0.316156 -0.707832       NaN -0.416589  
1  0.406830  1.345932       NaN -1.874817  
 
pd.concat([df1,df2],ignore_index=True)  
 
          a         b         c         d  
0 -0.848557 -1.163877 -0.306148 -1.163944  
1  1.358759  1.159369 -0.532110  2.183934  
2  0.532117  0.788350  0.703752 -2.620643  
3 -0.316156 -0.707832       NaN -0.416589  
4  0.406830  1.345932       NaN -1.874817  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

排序去重取第一条数据

df_user = df_user.sort_values(['#account_id'],ascending=False)
df_user_distinct = df_user.groupby(['#account_id']).head(1)
1
2

根据多列分组，对其中一列进行统计

根据A、B列分组，对C列进行求和：

Result=df.groupby(['A','B'])[['C']].sum()

根据A、B列分组，对C列进行计数：

Result=df.groupby(['A','B'])[['C']].count()

1
2
3
4
5
6
7
8

根据某列分组后，拼接字符串列

order_info['productname'] = order_info.groupby(['userid_db_order'])['productname'].transform(lambda x : ' '.join(x)) 

order_info = order_info.drop_duplicates() 

print(order_info) 

1
2
3
4
5
6
7
8
9

索引排序

将索引排序通常会很有用，在 Pandas 中，我们可以对 dataframe 调用 sort_index 方法进行排序。

df.sort_index(ascending=False).head(5) #inplace=True to apple the sorting in place
1

将参数 ascending 设置为 false，数据就会呈降序排列。

解除索引

当你将一列设置为索引的时候，它就不再是数据的一部分了。如果你想将索引恢复为数据，调用 set_index 相反的方法 reset_index 即可：

# Returning an index to data
df = df.reset_index('water_year')
df.head(5)
1
2
3

这一语句会将索引恢复成数据形式

修改列—对数据集应用函数-apply 和 applymap

有时你想对数据集中的数据进行改变或者某种操作。比方说，你有一列年份的数据，你需要新的一列来表示这些年份对应的年代。Pandas 中有两个非常有用的函数，apply 和 applymap。

# Applying a function to a column
def base_year(year):
    base_year = year[:4]
    base_year= pd.to_datetime(base_year).year
    return base_year

df['year'] = df.water_year.apply(base_year)
df.head(5)
1
2
3
4
5
6
7
8

上面的代码创建了一个叫做 year 的列，它只将 water_year 列中的年提取了出来。这就是 apply 的用法，即对一列数据应用函数。如果你想对整个数据集应用函数，就要使用 applymap 。

操作数据集的结构–groupby

另一常见的做法是重新建立数据结构，使得数据集呈现出一种更方便并且（或者）有用的形式。

掌握这些转换最简单的方法就是观察转换的过程。

首先，是 groupby ：

#Manipulating structure (groupby, unstack, pivot)
# Grouby
df.groupby(df.year // 10 *10).max()
1
2
3

groupby 会按照你选择的列对数据集进行分组。上例是按照年代分组。不过仅仅这样做并没有什么用，我们必须对其调用函数，比如 max 、 min 、mean 等等。例中，我们可以得到 90 年代的均值。

你也可以按照多列进行分组：

# Grouping by multiple columns
decade_rain = df.groupby([df.year // 10 * 10, df.rain_octsep // 1000 * 1000])[['outflow_octsep',                                                              'outflow_decfeb', 'outflow_junaug']].mean()
decade_rain
1
2
3

接下来是 unstack ，它可以将一列数据设置为列标签。最好还是看看实际的操作：

# Unstacking
decade_rain.unstack(0)
1
2

这条语句将上例中的 dataframe 转换为下面的形式。它将第 0 列，也就是 year 列设置为列的标签。

让我们再操作一次。这次使用第 1 列，也就是 rain_octsep 列：

# More unstacking
decade_rain.unstack(1)
1
2

Pivoting

在进行操作之前，我们先创建一个用于演示的 dataframe :

# Create a new dataframe containing entries which 
# has rain_octsep values of greater than 1250
high_rain = df[df.rain_octsep > 1250]
high_rain
1
2
3
4

我们将会在上面的代码产生的 dataframe里演示轴向旋转（pivoting）。

轴旋转其实就是我们之前已经看到的那些操作的一个集合。首先，它会设置一个新的索引（set_index()），然后对索引排序（sort_index()），最后调用 unstack 。以上的步骤合在一起就是 pivot 。接下来看看你能不能搞清楚下面的代码在干什么：

#Pivoting
#does set_index, sort_index and unstack in a row
high_rain.pivot('year', 'rain_octsep')[['outflow_octsep', 'outflow_decfeb', 'outflow_junaug']].fillna('')
1
2
3

注意，最后有一个 .fillna(’’) 。pivot 产生了很多空的记录，也就是值为 NaN 的记录。 fillna(’’)填充数据 。你也可以用别的别的东西，比方说 0 。我们也可以使用 dropna(how = ‘any’) 来删除有 NaN 的行，不过这样就把所有的数据都删掉了，所以不这样做。

上面的 dataframe 展示了所有降雨超过 1250 的 outflow 。诚然，这并不是讲解 pivot 实际应用最好的例子，但希望你能明白它的意思。看看你能在你的数据集上得到什么结果。

fillna

 dataframe.fillna({'code':'code', 'date':'date'})，第一个code和date分别表示列，后面的表示在该列填充的内容
1

合并数据集

有时你有两个相关联的数据集，你想将它们放在一起比较或者合并它们。好的，没问题，在 Pandas 里很简单：

# Merging two datasets together
rain_jpn = pd.read_csv('jpn_rain.csv')
rain_jpn.columns = ['year', 'jpn_rainfall']

uk_jpn_rain = df.merge(rain_jpn, on='year')
uk_jpn_rain.head(5)
1
2
3
4
5
6

首先你需要通过 on 关键字来指定需要合并的列。通常你可以省略这个参数，Pandas 将会自动选择要合并的列。

两个数据集在年份这一类上合并了。jpn_rain 数据集只有年份和降雨量两列，通过年份列合并之后，jpn_rain 中只有降雨量那一列合并到了 UK_rain 数据集中。

也可以设置不同的合并方式 left，right，inner

activite_user = df_user_distinct.merge(order_user_100,left_on='#account_id',right_on='userid',how='left')
1

合并后去重

df_user = df_user.sort_values(['account_id'],ascending=False)
df_user_distinct = df_user.groupby(['account_id']).head(1)
1
2

使用 Pandas 快速作图

Matplotlib 很棒，但是想要绘制出还算不错的图表却要写不少代码，而有时你只是想粗略的做个图来探索下数据，搞清楚数据的含义。Pandas 通过 plot 来解决这个问题：

# Using pandas to quickly plot graphs
uk_jpn_rain.plot(x='year', y=['rain_octsep', 'jpn_rainfall'])
1
2

这会调用 Matplotlib 快速轻松地绘出了你的数据图。

保存你的数据集

在清洗、重塑、探索完数据之后，你最后的数据集可能会发生很大改变，并且比最开始的时候更有用。你应该保存原始的数据集，但是你同样应该保存处理之后的数据。

# Saving your data to a csv
df.to_csv('uk_rain.csv')
order_user_all_userid.to_excel('app_order_user_all_userid1.xlsx')
1
2
3

上面的代码将会保存你的数据到 csv 文件以便下次使用。

对比文件内容

例子:查询bl.txt文件与ba.txt文件的数据是否一致对应

import pandas as pd


def parse_change_Record():
    rawsnppath="/Users/joe/workspace/diffrentgt/ba.txt"
    fixsnppath = "/Users/joe/workspace/diffrentgt/bl.txt"
    rawsnp = pd.read_table(rawsnppath, dtype=str)
    fixsnp = pd.read_table(fixsnppath, dtype=str)
    for index, row in fixsnp.iterrows():
        if len(rawsnp[(rawsnp['#rsid'] == row['#rsid']) & (rawsnp['genotype'] == row['genotype'])].index.tolist()) > 0:
            print("找到对应%s, %s" % (row['#rsid'], row['genotype']))
        else:
            print("未找到对应%s, %s" % (row['#rsid'], row['genotype']))


parse_change_Record()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

读写excel

    with open("today.xls", "wb") as todaycsv:
        todaycsv.write(r.content)
    sheet = pd.read_excel("today.xls", header=1)
    print(sheet)
1
2
3
4

获取单列转为list（去重）

 barcode_list_df = pd.read_table(barcode_list_path, dtype=str, header=None)
    print(barcode_list_df)
    barcode_list_df_columns = barcode_list_df[0]
    columns = barcode_list_df_columns.tolist()
    barcodes = list(set(columns).difference())
1
2
3
4
5

修改列名

如下：
   a  b
0  1  1
1  2  2
2  3  3


1、修改列名a，b为A、B。

df.columns = ['A','B']

2、只修改列名a为A

df.rename(columns={'a':'A'})
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意：有的时候收到的csv文件的列名是中文的，想要修改列名就需要在字符串前面加上 u，而且需要df=df.rename,否则更改不会生效

  df = pd.read_excel("today.xls", header=1)
   df = df.rename(columns={u'代码':'code',u'名称':'name',u'最新价':'new_price',u'涨跌幅':'change',u'涨跌额':'change_money',u'买入':'buy',u'卖出':'sell',u'成交量':'volume',u'成交额':'volume_money',u'今开':'open',u'昨收':'close',u'最高':'high',u'最低':'low'})
1
2

新增列

新增时间列

    today = datetime.date.today()
    df['date'] = today
1
2

输出如下：

          code  name  new_price  ...       high        low        date
0     sz300758  七彩化学  51.810001  ...  56.299999  51.810001  2019-04-09
1     sz300416  苏试试验  25.200001  ...  29.480000  25.200001  2019-04-09
2     sz300176  派生科技  27.910000  ...  27.910000  27.910000  2019-04-09
3     sz300761  立华股份  66.830002  ...  69.000000  66.830002  2019-04-09
4     sz000830  鲁西化工  17.840000  ...  18.480000  17.840000  2019-04-09
1
2
3
4
5
6

新增列由老的列处理而来–删除不要的部分

    df['code'] = df['hscode'].str.replace("sz", "")
	或者
    df['code'] = df['hscode'].map(lambda x: x.lstrip('sz').lstrip('sh').rstrip('sh'))
1
2
3

输出如下：

        hscode  name  new_price  ...        low        date    code
0     sz300758  七彩化学  51.810001  ...  51.810001  2019-04-09  300758
1     sz300416  苏试试验  25.200001  ...  25.200001  2019-04-09  300416
2     sz300176  派生科技  27.910000  ...  27.910000  2019-04-09  300176
3     sz300761  立华股份  66.830002  ...  66.830002  2019-04-09  300761
1
2
3
4
5

新增列由老的列处理而来–拼接两个字段

  df['id'] = df['code'].str.cat(df['date'].map(lambda x : str(x)))
1

输出如下：

启动环境 dev
        hscode  name  new_price  ...        date    code                id
0     sz300758  七彩化学  51.810001  ...  2019-04-09  300758  3007582019-04-09
1     sz300416  苏试试验  25.200001  ...  2019-04-09  300416  3004162019-04-09
2     sz300176  派生科技  27.910000  ...  2019-04-09  300176  3001762019-04-09
3     sz300761  立华股份  66.830002  ...  2019-04-09  300761  3007612019-04-09
1
2
3
4
5
6

DataFrame数据保留两位小数显示

format = lambda x: '%.2f' % x
df = df.applymap(format)
print df.loc["2017-04-26":"2017-06-15"]#默认打印全部列
1
2
3

以csv格式存放

import numpy as np
import pandas as pd
import pandas_datareader.data as web
import datetime

'''pd.read_csv test'''

df_csvsave = web.DataReader("600018.SS","yahoo",datetime.datetime(2019,1,1),datetime.date.today())
print (df_csvsave)
#print (df_csvsave.index)
#print (df_csvsave.colums)

df_csvsave.to_csv(r'C:\Users\15461\Desktop\table.csv',columns=df_csvsave.columns,index=True)
1
2
3
4
5
6
7
8
9
10
11
12
13

pandas表格导入MySQL数据库

pandas提供了将数据便捷存入关系型数据库的方法，在新版的pandas中，主要是已sqlalchemy方式与数据建立连接，支持MySQL、Postgresql、Oracle、MS SQLServer、SQLite等主流数据库。本例以MySQL数据库为代表，展示将获取到的股票数据存入数据库的方法,其他类型数据库请参考sqlalchemy官网文档的create_engine部分。

常用参数说明：

name:表名，pandas会自动创建表结构
con：数据库连接，最好是用sqlalchemy创建engine的方式来替代con
flavor:数据库类型 {‘sqlite’, ‘mysql’}, 默认‘sqlite’，如果是engine此项可忽略
schema:指定数据库的schema，默认即可
if_exists:如果表名已存在的处理方式 {‘fail’, ‘replace’, ‘append’},默认‘fail’
index:将pandas的Index作为一列存入数据库，默认是True
index_label:Index的列名
chunksize:分批存入数据库，默认是None，即一次性全部写人数据库
dtype:设定columns在数据库里的数据类型，默认是None
1
2
3
4
5
6
7
8
9

调用方法：

from sqlalchemy import create_engine
import tushare as ts

df = ts.get_tick_data('600848', date='2014-12-22')
engine = create_engine('mysql://user:passwd@127.0.0.1/db_name?charset=utf8')

#存入数据库
df.to_sql('tick_data',engine)

#追加数据到现有表
#df.to_sql('tick_data',engine,if_exists='append')
1
2
3
4
5
6
7
8
9
10
11

计算各列数据总和并作为新行添加到末尾

df['Col_sum'] = df.apply(lambda x: x.sum(), axis=1)
1

计算各行数据总和并作为新列添加到末尾

df.loc['Row_sum'] = df.apply(lambda x: x.sum())
1

最终数据结果：

                A         B         C         D         E   Col_sum
0        0.673092  0.230338 -0.171681  0.312303 -0.184813  0.859238
1       -0.504482 -0.344286 -0.050845 -0.811277 -0.298181 -2.009071
2        0.542788  0.207708  0.651379 -0.656214  0.507595  1.253256
3       -0.249410  0.131549 -2.198480 -0.437407  1.628228 -1.125520
Row_sum  0.461987  0.225310 -1.769627 -1.592595  1.652828 -1.022097

1
2
3
4
5
6
7

求单列的总和平均等

在pandas中进行列级别的分析很简单。下面是一些例子：

df["Jan"].sum(), df["Jan"].mean(),df["Jan"].min(),df["Jan"].max()
1

求一行中多个列的总和

df["total"] = df["Jan"] + df["Feb"] + df["Mar"]
1

或者
i代表要计算的行

Row_sum = df.iloc[i,0：].sum()
1

获取非空的行

例子：

# df为需要筛选的数据框，col为选择非空依赖的列名
df = df[(df['col'].notnull()) & (df['col'] != "")& (df['col'].notna())]
1
2

获取值为空的行

例子：

# df为需要筛选的数据框，col为选择空值的列名
df = df[(df['col'].isnull()) | (df['col'] == "") | (df['col'].isna())]
1
2

选择两个时间之间的dataframe行

df['date'] = pd.to_datetime(df['date'])
df = (df['date'] > '2019-4-8 00:00:00') & (df['date'] <= '2019-4-14 18:00:00'
)
1
2
3

注意，时间列需要使用pd.to_datetime(df[‘date’])先转换为时间格式。

删除列

采用drop方法，有下面三种等价的表达式：

1. DF= DF.drop('column_name', 1)；

2. DF.drop('column_name',axis=1, inplace=True)

3. DF.drop(DF.columns[[0,1, 3]], axis=1,inplace=True)   # Note: zero indexed 改动DF本身

4.DF_new=DF.drop(DF.columns[[0,1,3,4,5,6,7]], axis=1) # 赋值给新df
1
2
3
4
5
6
7

默认axis=0,drop是删除行。
设置axis=1（按列方向操作）、inplace=True（修改完数据，在原数据上保存）

注意：凡是会对原数组作出修改并返回一个新数组的，往往都有一个 inplace可选参数。如果手动设定为True（默认为False），那么原数组直接就被替换。也就是说，采用inplace=True之后，原数组名（如2和3情况所示）对应的内存值直接改变；而采用inplace=False之后，原数组名对应的内存值并不改变，需要将新的结果赋给一个新的数组或者覆盖原数组的内存位置（如1情况所示）

循环遍历行

方式一

  for index,row in df.iterrows():
        id =row["id"]
        x=row["x"]
        y=row["y"]
        judge=row["judge"]
1
2
3
4
5

方式二

for row in df.itertuples(index=True, name='Pandas'):
    print getattr(row, "c1"), getattr(row, "c2")
1
2

方式三

df.apply()
遍历行并访问函数

def valuation_formula(x, y):
    return x * y * 0.5
 
df['price'] = df.apply(lambda row: valuation_formula(row['x'], row['y']), axis=1)
1
2
3
4

方式四

使用df.iloc函数，如下所示：

for i in range(0, len(df)):
    print df.iloc[i]['c1'], df.iloc[i]['c2']
1
2

计算时间差

import time
def compute_return_days(claim_time,time_view):
    try:
        # 计算时间差
        day1_time = time.strptime(str(time_view), "%Y-%m-%d %H:%M:%S.%f")
        day2_time = time.strptime(str(claim_time), "%Y-%m-%d %H:%M:%S.%f")
        day_time_num = (int(time.mktime(day2_time)) - int(time.mktime(day1_time))) / (24 * 60 * 60)
        
        # 转成天为单位 计算时间差
        day1_str = time.strftime("%Y-%m-%d", day1_time)
        day2_str = time.strftime("%Y-%m-%d", day2_time)
        day1 = time.strptime(str(day1_str), "%Y-%m-%d")
        day2 = time.strptime(str(day2_str), "%Y-%m-%d")
        day_num = (int(time.mktime(day2)) - int(time.mktime(day1))) / (24 * 60 * 60)    
        
        
        return day_num
    except:
        return 99999


print(compute_return_days('2022-01-12 05:48:21.000','2022-01-12 10:48:21.000'))


df['diff_date'] = df_order_td.apply(lambda row: compute_return_days(row['#event_time'], row['#server_time']), axis=1）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

分组后 组内排序

根据#account_id进行分组后，组内根据date_num进行由小到大排序，注意date_num需要是数值类型

df_hp_barcode['sort_id'] = df_hp_barcode.groupby(['#account_id'])['date_num'].rank()

1
2
3

rank的参数为：
一、ascending: 排序或者降序，默认为1，由小到大，ascending = 0意味着降序，即从大到小排序

二、method:遇到排序中值相同的情况，该如何排序，参数值 有’average’，‘min’，‘max’，‘first’，‘dense’，默认为’average’
如何对具有相同值（即ties）的记录组进行排名：
average：组的平均等级；
min：组中最低的排名；
max：组中最高等级；
first : 按排列顺序排列，依次排列；
dense：类似于 ‘min’，但组之间的排名始终提高1

df_hp_barcode['sort_id'] = df_hp_barcode.groupby(['#account_id'])['date_num'].rank(ascending=1,method='first')

1
2
3