设置中文

sep=’\t’

csv文件默认的是以逗号为分隔符，但是中文中逗号的使用率很高，爬取中文数据时就容易造成混淆，所以使用pandas写入csv时可以设置参数 sep=’\t’ ，即以tab为分隔符写入。

一、读取和写入

1、可读文件

img

img

img

  • filepath_or_buffer #需要读取的文件及路径
  • sep / delimiter 列分隔符，普通文本文件，应该都是使用结构化的方式来组织，才能使用dataframe
  • header 文件中是否需要读取列名的一行，header=None(使用names自定义列名,否则默认0,1,2,…)，header=0（将首行设为列名）
  • names 如果header=None，那么names必须制定！否则就没有列的定义了。
  • shkiprows= 10 # 跳过前十行
  • nrows = 10 # 只去前10行
  • usecols=[0,1,2,…] #需要读取的列，可以是列的位置编号，也可以是列的名称
  • parse_dates = [‘col_name’] # 指定某行读取为日期格式
  • index_col = None /False /0，重新生成一列成为index值，0表示第一列，用作行索引的列编号或列名。可以是单个名称/数字或由多个名称/数字组成的列表（层次化索引）
  • error_bad_lines = False # 当某行数据有问题时，不报错，直接跳过，处理脏数据时使用
  • na_values = ‘NULL’ # 将NULL识别为空值
  • encoding=’utf-8’ #指明读取文件的编码，默认utf-8

读取

1
2
3
4
import pandas as pd
for inputfile in os.listdir(inputfile_dir):
    pd.read_csv(inputfile, header=None)　　　　　　　　　　　　　　　　 　　 #header=None表示原始文件数据没有列索引，这样的话read_csv会自动加上列索引
    pd.to_csv(outputfile, mode='a', index=False, header=False)　　　　　　#header=0表示不保留列名，index=False表示不保留行索引，mode='a'表示附加方式写入，文件原有内容不会被清除

(1)不指定sheet参数，默认读取第一个sheet，

1
df=pd.read_excel("data_test.xlsx")

(2)指定sheet名称读取，

1
df=pd.read_excel("data_test.xlsx",sheet_name="test1")

(3)指定sheet索引号读取，

1
2
df=pd.read_excel("data_test.xlsx",sheet_name=0)#sheet索引号从0开始
pandas.read_csv(filepath_or_buffer, sep=’\t’, header=’infer’, names=None,index_col=None, dtype=None, engine=None, nrows=None)

读取全部文件并转成list

1
2
3
4
5
6
7
8
9
import pandas as pd
import numpy as np
import itertools

# 分块处理大文件
df = pd.read_csv('1.csv',sep=",",encoding='utf-8')
print(df)
train_data = np.array(df)
train_x_list=train_data.tolist()

写入

1
DataFrame.to_csv(path_or_buf=None, sep=’,’, na_rep=”, columns=None,header=True,index=True,index_label=None,mode=’w’,encoding=None)

使用to_csv函数实现以csv格式存储
使用read_csv函数来读取csv文件

1
2
3
4
5
import  pandas as pd
a=[{'_id': 1, 'name': '张三', 'Chinese': 67, 'Math': 89, 'English': 97},{'_id': 2, 'name': '李四', 'Chinese': 65, 'Math': 49, 'English': 78}]
df=pd.DataFrame(list(a))
df.to_csv("ddd.csv", index=False, sep=',',encoding='gb2312')
print(df)

1.1、head

1
2
3
pd.read_csv(data, header=0) # 第一行
pd.read_csv(data, header=None) # 没有表头
pd.read_csv(data, header=[0,1,3]) # 多层索引MultiIndex

1.2、数据类型

1
2
3
4
5
dtype可以指定各数据列的数据类型
# 传入类型名称，或者以列名为键、以指定类型为值的字典
pd.read_csv(data, dtype=np.float64) # 所有数据均为此数据类型
pd.read_csv(data, dtype={'c1':np.float64, 'c2': str}) # 指定字段的类型
pd.read_csv(data, dtype=[datetime, datetime, str, float]) # 依次指定

1.3、引擎

1
2
3
4
#使用的分析引擎可以选择C或Python。C语言的速度最快，Python语言的功能最为完善，一般情况下，不需要另行指定。

# 格式为engine=None，其中可选值有{'c', 'python'}
pd.read_csv(data, engine='c')

1.4、时间处理

parse_dates参数用于对时间日期进行解析

1
2
3
4
5
6
7
8
9
10
# 布尔型、整型组成的列表、列表组成的列表或者字典，默认为False

pd.read_csv(data, parse_dates=True) # 自动解析日期时间格式
pd.read_csv(data, parse_dates=['年份']) # 指定日期时间字段进行解析

# 将第1、4列合并解析成名为“时间”的时间类型列

pd.read_csv(data, parse_dates={'时间':[1,4]})
 #to_datetime将字符串转成时间格式 ，可以指定列
df["日志接收时间"] = pd.to_datetime(df["日志接收时间"])
  • infer_datetime_format被设定为True并且parse_dates可用，那么Pandas将尝试转换为日期类型。
1
2
# 布尔型，默认为False
pd.read_csv(data, parse_dates=True, infer_datetime_format=True)
  • 对于DD/MM格式的日期类型，如日期2020-01-06，如果dayfirst=True，则会转换成2020-06-01。
1
2
# 布尔型，默认为False
pd.read_csv(data, dayfirst=True, parse_dates=[0])
  • cache_dates如果为True，则使用唯一的转换日期缓存来应用datetime转换。解析重复的日期字符串，尤其是带有时区偏移的日期字符串时，可能会大大提高速度。
1
2
3
# 布尔型，默认为True

pd.read_csv(data, cache_dates=False)

1.5、分块处理

1
2
3
4
5
6
7
8
9
10
11
12
# 分块处理大文件

df_iterator = pd.read_csv('cve.csv', chunksize=200,sep=",",encoding='gbk')
for index,df_tmp in enumerate(df_iterator):
    for i in range(len(df_tmp)):
         print(df_tmp.iloc[i])
 
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
>>> [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

1.6、跳过指定行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 类似列表的序列或者可调用对象

# 跳过前三行
pd.read_csv(data, skiprows=2)

# 跳过前三行
pd.read_csv(data, skiprows=range(2))

# 跳过指定行
pd.read_csv(data, skiprows=[24,234,141])

# 跳过指定行
pd.read_csv(data, skiprows=np.array([2, 6, 11]))

# 隔行跳过
pd.read_csv(data, skiprows=lambda x: x % 2 != 0)

跳过空行

1
2
3
4
5
6
7
8
skip_blank_lines指定是否跳过空行，如果为True，则跳过空行，否则数据记为NaN。

# 布尔型，默认为True
# 不跳过空行
pd.read_csv(data, skip_blank_lines=False)

# 删除空数据所在的行
df.dropna(axis=0)

1.7、空值处理，跳过**[感觉这个适合使用】

1
2
3
4
5
na_filter是否检查丢失值（空字符串或空值）。设定na_filter=False可以提升读取速度。
# 布尔型，默认为True
pd.read_csv(data, na_filter=False) # 不检查

[1,3,4,'','','']

1.8、过滤字符串

1
2
3
4
5
6
7
8
escapechar，用于过滤数据中的该转入符

# 长度为1的转义字符串，默认为None

data = 'a,b,c~1,2,3~4,5,6dd\nd'
df=pd.read_csv(StringIO(data), lineterminator='~',quotechar='"',escapechar='\n')
for i in range(len(df)):
    print(list(df.iloc[i]))

img

1.9、注释标识comment，指示不应分析行的部分

1
2
3
4
如果在一行的开头找到该标识，则将完全忽略该行。此参数必须是单个字符。像空行一样
s = '# notes\na,b,c\n# more notes\n1,2,3'
df=pd.read_csv(StringIO(s), sep=',', comment='#', skiprows=1)
print(df)

img

1.10、drop 删除数据

​ drop 中 axis=0 表示行，axis=1 表示列

1
2
3
4
5
  
删除无用的列，列索引：'name','name1'；inplace参数指是否替代原来的df
          data.drop(labels=['name','name1'],axis = 1,inplace=True)     
删除无用的行，行索引：'涨跌'
          df.drop(['涨跌'], axis=0, inplace=True

2、逐行读取【多行读取】

iloc和loc
loc按照标签取列，iloc按照位置取列

1
2
3
4
5
6
7
8
9
10
# 第1行
print(df.iloc[0])
# 前3行
print(df.iloc[:3])
# 第1列
print(df.iloc[:, 0])
# 前2列
print(df.iloc[:, :2])

exam_Y=examDf.loc[:,'学习时间']

3、获取其他信息

1
2
3
4
5
6
7
8
#获取文件头
df.head()
#获取后五行
df.tail()
#查看维度信息
df.shape
#查看数据表基本信息（维度、列名称、数据格式、所占空间等）
data.info()

4、用pandas读取非文件类型

4.1、pandas读取字符串

1
2
3
4
5
from io import StringIO
data = 'a,b,c~1,2,3~4,5,6'
df=pd.read_csv(StringIO(data), lineterminator='~')
for i in range(len(df)):
    print(list(df.iloc[i]))

4.2、读取字节数据

1
2
3
4
5
6
from io import BytesIO
data = (b'word,length\n'
        b'Tr\xc3\xa4umen,7\n'
        b'Gr\xc3\xbc\xc3\x9fe,5')

pd.read_csv(BytesIO(data))

二、数据处理基础

1、字符串处理

1.1、cat函数用于字符串的拼接

1
2
3
4
df = pd.read_csv('cve.csv',sep=",",encoding='gbk')
print(list(df.head()))
z=df["0"].str.cat(df["poc"],sep='-'*3)
print(list(z))

img

1.2、contains：判断某个字符串是否包含给定字符

1
2
3
4
df = pd.read_csv('cve.csv',sep=",",encoding='gbk')
print(list(df.head()))
z=df["0"].str.contains("2021")
print(list(z))

img

1.3、startswith/endswith：判断某个字符串是否以…开头/结尾

1
2
3
4
5
6
df= pd.read_csv('cve.csv',sep=",",encoding='gbk')
print(list(df.head()))
z=df["0"].str.startswith("cve")
H=df["0"].str.endswith("2021")
print(list(z))
print(list(H))

img

1.4、count：计算给定字符在字符串中出现的次数

1
2
3
4
df = pd.read_csv('ip.csv',sep=",",encoding='utf-8')
print(list(df.head()))
z=df["city"].str.count("3")
print(list(z))

img

1.5、get：获取指定位置的字符串

1
2
3
4
5
6
7
8
df = pd.read_csv('ip.csv',sep=",",encoding='utf-8')
print(list(df.head()))
z=df["ip"].str.get(-1)   #转成字符串最后一个
z1=df["ip"].str.split(".")  #以'.'分割
z2=df["ip"].str.split(".").str.get(0)
print(list(z))
print(list(z1))
print(list(z2))

img

1.6、len：计算字符串长度

1
2
3
4
df = pd.read_csv('ip.csv',sep=",",encoding='utf-8')
print(list(df.head()))
z=df["ip"].str.len()
print(list(z))

img

1.7、upper/lower：英文大小写转换

1
2
3
4
5
6
df = pd.read_csv('cve.csv',sep=",",encoding='gbk')
print(list(df.head()))
z1=df["name"].str.upper()  #转成大写
z2=df["name"].str.lower()   #转成小写
print(list(z1))
print(list(z2))

img

1.8、pad+side参数/center：在字符串的左边、右边或左右两边添加给定字符

1.9、 slice_replace：使用给定的字符串，替换指定的位置的字符

1
2
df = pd.read_csv('cve.csv',sep=",",encoding='gbk')
z=df["name"].str.slice_replace(4,8,"*"*4)

img

1.10、replace：将指定位置的字符，替换为给定的字符串[可以使用正则替换

1
2
3
df = pd.read_csv('cve.csv',sep=",",encoding='gbk')
z=df["name"].str.replace("-","_")
z1=df["name"].str.replace("-\d{4}-","-xxxx-")

img

1.11、strip/rstrip/lstrip：去除空白符、换行符

1
2
df = pd.read_csv('cve.csv',sep=",",encoding='gbk')
z=df["name"].str.str.strip()

1.12、findall：利用正则表达式，去字符串中匹配，返回查找结果的列表

1
2
df = pd.read_csv('cve.csv',sep=",",encoding='gbk')
z1=df["name"].str.findall("cve.\d+")

img

2、判断重复值-duplicated()

1
df2.duplicated(subset=["col3","col4"])

3、groupby分组

3.1、count

过滤csv重复行
根据ip、city进行分组，并根据每组的isp计数

1
t=df.groupby(["ip","city"])["isp"].count()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import pandas as pd
import numpy as np
import itertools

# 分块处理大文件

df = pd.read_csv('1.csv',sep=",",encoding='utf-8')
#根据
t=df.groupby(["ip","city"]).count()
temp=np.array(t).tolist()
z=list(t.index)
info=list()
for  i in range(len(z)):
    info.append([z[i],temp[i][0]])
print(info)

结果：[[('111.192.103.3', '东城区'), 3], [('111.192.98.74', '东城区'), 3], [('122.115.227.215', '北京市'), 2]]

3.2、sum

  • 根据ip进行分组，并对每组的size求和
1
t=df.groupby(["ip"])["size"].sum()
  • 仅按city 为东城区，对ip 和city进行分组，并对每组的isp进行计数
1
t=df[df["city"]=="东城区"].groupby(["ip","city"])["isp"].count()

过滤字段 清洗

1
z=df[(df["源境内外"]=="境外")&(df["目的境内外"]=="境内")].groupby(t)["目的IP地址"].count()

3.3、agg

1.将单个函数应用于组中的列

img

img

2.将多个函数应用于组中的列

img

4、排序

4.1、sort_values()

1
t=df.sort_values("日志接收时间")

4.2、sort_index()

1
info1=info.sort_index() info1=info.sort_index(axis="columns")

5、排名 rank方法。

img

6、合并拼接

  • merge方法主要基于两个dataframe的共同列进行合并，
  • join方法主要基于两个dataframe的索引进行合并，
  • concat方法是对series或dataframe进行行拼接或列拼接。

6.1、concat（）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
info = pd.concat([info,df],axis=0,ignore_index=True)

DEMO:	
judge=0
for i in os.listdir("file"):
    df=pd.read_csv("file/"+i,index_col=None, header=0).copy()
    if judge==0:
        info=df
    else:
        info = pd.concat([info,df],axis=0,ignore_index=True)

    judge+=1

info = info.sort_values("日志接收时间")
print(info)

6.2、Merge方法

pandas的merge方法是基于共同列，将两个dataframe连接起来。merge方法的主要参数：

  • left/right：左/右位置的dataframe。

  • how：数据合并的方式。left：基于左dataframe列的数据合并；right：基于右dataframe列的数据合并；outer：基于列的数据外合并（取并集）；inner：基于列的数据内合并（取交集）；默认为’inner’。

  • on：用来合并的列名，这个参数需要保证两个dataframe有相同的列名。

  • left_on/right_on：左/右dataframe合并的列名，也可为索引，数组和列表。

  • left_index/right_index：是否以index作为数据合并的列名，True表示是。

  • sort：根据dataframe合并的keys排序，默认是。

  • suffixes：若有相同列且该列没有作为合并的列，可通过suffixes设置该列的后缀名，一般为元组和列表类型。

​ merges通过设置how参数选择两个dataframe的连接方式，有内连接，外连接，左连接，右连接，下面通过例子介绍连接的含义。

6.2.1 内连接[相同的列的交集】

　　how=’inner’，dataframe的链接方式为内连接，我们可以理解基于共同列的交集进行连接，参数on设置连接的共有列名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 单列的内连接
# 定义df1  取共同列alpha值的交集进行连接。

import pandas as pd
import numpy as np
df1 = pd.DataFrame({'alpha':['A','B','B','C','D','E'],'feature1':[1,1,2,3,3,1],
            'feature2':['low','medium','medium','high','low','high']})
# 定义df2
df2 = pd.DataFrame({'alpha':['A','A','B','F'],'pazham':['apple','orange','pine','pear'],
            'kilo':['high','low','high','medium'],'price':np.array([5,6,5,7])})
# print(df1)
# print(df2)
# 基于共同列alpha的内连接

df3 = pd.merge(df1,df2,how='inner',on='alpha')
print(df3)

6.2.2 外连接[相同的列的并集】

　　how=’outer’，dataframe的链接方式为外连接，我们可以理解基于共同列的并集进行连接，参数on设置连接的共有列名。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 单列的外连接  若两个dataframe间除了on设置的连接列外并无相同列，则该列的值置为NaN

# 定义df1

df1 = pd.DataFrame({'alpha':['A','B','B','C','D','E'],'feature1':[1,1,2,3,3,1],
                'feature2':['low','medium','medium','high','low','high']})

# 定义df2

df2 = pd.DataFrame({'alpha':['A','A','B','F'],'pazham':['apple','orange','pine','pear'],
                        'kilo':['high','low','high','medium'],'price':np.array([5,6,5,7])})

# 基于共同列alpha的内连接

df4 = pd.merge(df1,df2,how='outer',on='alpha')
print(df4)

6.2.3 左连接[左表加相同的列的交集】

　　how=’left’，dataframe的链接方式为左连接，我们可以理解基于左边位置dataframe的列进行连接，参数on设置连接的共有列名。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 单列的左连接
# 定义df1
df1 = pd.DataFrame({'alpha':['A','B','B','C','D','E'],'feature1':[1,1,2,3,3,1],
    'feature2':['low','medium','medium','high','low','high']})

# 定义df2
df2 = pd.DataFrame({'alpha':['A','A','B','F'],'pazham':['apple','orange','pine','pear'],
                        'kilo':['high','low','high','medium'],'price':np.array([5,6,5,7])})

# 基于共同列alpha的左连接

df5 = pd.merge(df1,df2,how='left',on='alpha')
print(df5)


​ 因为df2的连接列alpha有两个’A’值，所以左连接的df5有两个’A’值，若两个dataframe间除了on设置的连接列外并无相同列，则该列的值置为NaN。

6.2.4 右连接[右表加相同的列的交集，数据以右表为基准】

　 how=’right’，dataframe的链接方式为左连接，我们可以理解基于右边位置dataframe的列进行连接，参数on设置连接的共有列名。 

1
2
3
4
5
6
7
8
9
10
11
12
13
# 单列的右连接
# 定义df1
df1 = pd.DataFrame({'alpha':['A','B','B','C','D','E'],'feature1':[1,1,2,3,3,1],
'feature2':['low','medium','medium','high','low','high']})

# 定义df2
df2 = pd.DataFrame({'alpha':['A','A','B','F'],'pazham':['apple','orange','pine','pear'],
                        'kilo':['high','low','high','medium'],'price':np.array([5,6,5,7])})

# 基于共同列alpha的右连接

df6 = pd.merge(df1,df2,how='right',on='alpha')
print(df6)

因为df1的连接列alpha有两个’B’值，所以右连接的df6有两个’B’值。若两个dataframe间除了on设置的连接列外并无相同列，则该列的值置为NaN。

6.2.5 基于多列的连接算法

　　多列连接的算法与单列连接一致，本节只介绍基于多列的内连接和右连接，读者可自己编码并按照本文给出的图解方式去理解外连接和左连接。
多列的内连接：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 多列的内连接
# 定义df1
df1 = pd.DataFrame({'alpha':['A','B','B','C','D','E'],'beta':['a','a','b','c','c','e'],
                    'feature1':[1,1,2,3,3,1],'feature2':['low','medium','medium','high','low','high']})

# 定义df2
df2 = pd.DataFrame({'alpha':['A','A','B','F'],'beta':['d','d','b','f'],'pazham':['apple','orange','pine','pear'],
                        'kilo':['high','low','high','medium'],'price':np.array([5,6,5,7])})
# 基于共同列alpha和beta的内连接

df7 = pd.merge(df1,df2,on=['alpha','beta'],how='inner')
print(df7)


多列的右连接：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 多列的右连接

# 定义df1
df1 = pd.DataFrame({'alpha':['A','B','B','C','D','E'],'beta':['a','a','b','c','c','e'],
                    'feature1':[1,1,2,3,3,1],'feature2':['low','medium','medium','high','low','high']})
# 定义df2
df2 = pd.DataFrame({'alpha':['A','A','B','F'],'beta':['d','d','b','f'],'pazham':['apple','orange','pine','pear'],
                        'kilo':['high','low','high','medium'],'price':np.array([5,6,5,7])})
print(df1)
print(df2)

# 基于共同列alpha和beta的右连接
df8 = pd.merge(df1,df2,on=['alpha','beta'],how='right')
print(df8)


6.2.6 基于index的连接方法

​ 前面介绍了基于column的连接方法，merge方法亦可基于index连接dataframe

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 基于column和index的右连接

# 定义df1
df1 = pd.DataFrame({'alpha':['A','B','B','C','D','E'],'beta':['a','a','b','c','c','e'],
                    'feature1':[1,1,2,3,3,1],'feature2':['low','medium','medium','high','low','high']})

# 定义df2
df2 = pd.DataFrame({'alpha':['A','A','B','F'],'pazham':['apple','orange','pine','pear'],
                        'kilo':['high','low','high','medium'],'price':np.array([5,6,5,7])},index=['d','d','b','f'])
print(df1)
print(df2)
# 基于df1的beta列和df2的index连接，left_on='beta' 表示左边这一列作为右边的索引
df9 = pd.merge(df1,df2,how='inner',left_on='beta',right_index=True)
df9

设置参数suffixes以修改除连接列外相同列的后缀名。

1
2
3
4
# 基于df1的alpha列和df2的index内连接

df9 = pd.merge(df1,df2,how='inner',left_on='beta',right_index=True,suffixes=('_df1','_df2'))
df9

7、时间序列，重采样

7.1、pd.date_range 如按月区间生成序列

1
date_range(start=None, end=None, periods=None, freq=None, tz=None,normalize=False, name=None, closed=None, **kwargs)

  • start 开始时间

  • end 结束时间

  • periods 固定日期范围，整数

  • normalize 若参数为True表示将start、end参数值正则化到午夜时间戳

  • name 生成时间索引对象名称

  • freq 日期偏移量，默认为D

1
2
3
pd.date_range('20200801','20200810')
pd.date_range(start='20200801',periods=10)
pd.date_range(end='20200810',periods=10)
别名 偏移量类型 说明
D Day 每日历日
B BusinessDay 每工作日
H Hour 每小时
T/min Minute 每分
S Second 每秒
L/ms Million 每毫秒
U Micro 每微妙
M MonthEnd 每月最后一个日历日
BM BusinessMonthEnd 每月最后一个工作日
MS MonthBegin 每月第一个日历日
BMS BusinessMonthBegin 每月第一个工作日
W-MON、W-TUE… Week 从指定的星期几开始算起，每周
WOM-1MON、WOM-2MON… WeekOfMonth 产生每月第一、二、三、四周的星期几，例如WOM-1MON表示每月的第一个星期一
Q-JAN、Q-FEB… QuarterEnd 对于以指定月份（JAN、FEB、…、DEC）结束的年度，每季度的最后一月的最后一个日历日
BQ-JAN、BQ-FEB… BusinessQuarterEnd 对于以指定月份（JAN、FEB、…、DEC）结束的年度，每季度的最后一月的最后一个工作日
QS-JAN、QS-FEB… QuarterBegin 对于以指定月份（JAN、FEB、…、DEC）结束的年度，每季度的最后一月的第一个日历日
BQS-JAN、BQS-FEB… BusinessQuarterBegin 对于以指定月份（JAN、FEB、…、DEC）结束的年度，每季度的最后一月的第一个工作日
A-JAN、A-FEB… YearEnd 每年指定月份最后一个日历日
BA-JAN、BA-FEB… BusinessYearEnd 每年指定月份最后一个工作日
AS-JAN、AS-FEB… YearBegin 每月指定月份第一个日历日
BAS-JAN、BAS-FEB… BusinessYearBegin 每月指定月份第一个工作日

7.2、resample 按时间聚合

1
2
3
4
5
import pandas as pd
index = pd.date_range('1/1/2000', periods=9, freq='T')
series = pd.Series(range(9), index=index)
z=series.resample('3T').sum()
print(z)

7.3、Timedelta

对日期和时间进行加减实际上就是把datetime往后或往前计算，得到新的datetime。加减可以直接用+和-运算符，需要导入timedelta这个类

1
2
3
4
#计算当前时间往后100天的日期
dt=now+pd.Timedelta(days=100)
#只显示年月日
dt.strftime('%Y-%m-%d')

8、离散处理

1、diff函数

第一个离散的元素差异

1
DataFrame.diff(self, periods=1, axis=0)

  • periods ： int，默认值1 用于计算差异的周期，接受负值。

  • axis ： {0或’index’，1或’columns’}，默认为0 区分行（0）或列（1）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
df = pd.DataFrame({'a': [1, 2, 3, 4, 5, 6],
...                    'b': [1, 1, 2, 3, 5, 8],
...                    'c': [1, 4, 9, 16, 25, 36]})
df
a  b   c
0  1  1   1
1  2  1   4
2  3  2   9
3  4  3  16
4  5  5  25
5  6  8  36
df.diff()
a    b     c
0  NaN  NaN   NaN
1  1.0  0.0   3.0
2  1.0  1.0   5.0
3  1.0  1.0   7.0
4  1.0  2.0   9.0

5 1.0 3.0 11.0

与前一列的差异

1
2
3
4
5
6
7
8
df.diff(axis=1)
a    b     c
0 NaN  0.0   0.0
1 NaN -1.0   3.0
2 NaN -1.0   7.0
3 NaN -1.0  13.0
4 NaN  0.0  20.0
5 NaN  2.0  28.0

与第3行的差异

1
2
3
4
5
6
7
8
df.diff(periods=3)
a    b     c
0  NaN  NaN   NaN
1  NaN  NaN   NaN
2  NaN  NaN   NaN
3  3.0  2.0  15.0
4  3.0  4.0  21.0
5  3.0  6.0  27.0

与以下行的差异

1
2
3
4
5
6
7
8
df.diff(periods=-1)
a    b     c
0 -1.0  0.0  -3.0
1 -1.0 -1.0  -5.0
2 -1.0 -1.0  -7.0
3 -1.0 -2.0  -9.0
4 -1.0 -3.0 -11.0
5  NaN  NaN   NaN

9、移动函数

9.1、移动函数shift

1
DataFrame.shift(periods=1, freq=None, axis=0, fill_value=<no_default>)
  • periods：表示移动的幅度，可正可负；默认值是1，1就表示移动一次。注意这里移动的都是数据，而索引是不移动的，移动之后没有对应值的，就赋值为NaN。
  • freq：DateOffset, timedelta, or time rule string，可选参数，默认值为None，只适用于时间序列。如果这个参数存在，那么会按照参数值移动时间索引，而数据值没有发生变化。
  • axis：表示按照哪个轴移动。axis=0表示index，横轴；axis=1表示columns，纵轴
  • fill_value：表示当我们数据发生了移动之后，产生的缺失值用什么数据填充。如果是数值型的缺失值，用np.nan；如果是时间类型的缺失值，用NaT（not a time）

10、时间连续性

但是存在一个问题，需要先按照时间排序，并且如果日期相同，也会判断错误

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import pandas as pd
t={"DateAnalyzed":["2018-03-18","2018-03-19","2018-03-20","2017-01-20","2018-09-25","2018-09-26","2018-09-27"],"Val":[0.470253,0.470253,0.470253,0.485949,0.467729,0.467729,0.467729]}

df=pd.DataFrame(t)
df["DateAnalyzed"]=pd.to_datetime(df["DateAnalyzed"])

print(df.dtypes)
dt = df['DateAnalyzed']

day = pd.Timedelta('1d')
in_block = ((dt - dt.shift(-1)).abs() == day) | (dt.diff() == day)

filt = df.loc[in_block]
breaks = filt['DateAnalyzed'].diff() != day
groups = breaks.cumsum()
print(groups)
for _, frame in filt.groupby(groups):
   print(frame, end='\n\n')

已解决时间连续性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import pandas as pd

# t={"DateAnalyzed":["2018-03-18","2018-03-19","2018-03-20","2017-01-20","2018-09-25","2018-09-26","2018-09-27"],"Val":[0.470253,0.470253,0.470253,0.485949,0.467729,0.467729,0.467729]}
df = pd.read_csv("all1.csv", index_col=None, header=0, error_bad_lines=False, encoding="gbk",parse_dates=True).copy()

df["日志接收时间"] = pd.to_datetime(df["日志接收时间"])
df=df.sort_values("日志接收时间")
dt = df['日志接收时间']
day = pd.Timedelta(minutes=1)
day1 = pd.Timedelta(minutes=0)
in_block = ((dt - dt.shift(1)).abs() == day) |((dt - dt.shift(1)).abs() == day1)
b=(in_block==False)
filt = df.loc[in_block]
groups = b.cumsum()
for _, frame in df.groupby(groups):
   print(frame, end='\n\n')

将TRUE和false颠倒
b=(in_block==False)

11、过滤

11.1、基本过滤

df[df[“size”]>=10] #过滤df的size字段中大于10的

11.2、过滤字段的某个值在一个列表中isin()

  • isin(),返回值为true false ，~取反

protocol=[“imap”] port=[“143.0”,”993.0”] #获取传输协议为imap的 df[(df[“传输协议”].isin(protocol))] #取反，获取目的端口不为143，993的 df[(df[“目的端口”].isin(port))]

11.3、获取多个字段的值

df[[‘源IP地址’, ‘目的IP地址’]]

12、算数方法

12.1、add

df1.add(df2,fill_value=0)

方法 描述 范例
add | radd 加法 df1.add(df2)==df1+df2df1.radd(df2)==df2+df1
sub | rsub 减法 df1.sub(df2)==df1-df2df1.rsub(df2)==df2-df1
div | rdiv 除法 df1.div(df2)==df1/df2df1.div(1)==1/df1[可以是数字,如果表里都是数字]
floordiv | rfloordiv 整除 df1.loordiv(df2)==df1//df2df1.rloordiv(df2)==df2//df1
mul | rmul 乘法 df1.mul(df2)==df1df2df1.rmul(df2)==df2df1
pow | rpow 幂次方 df1.pow(df2)==df1df2df1.rpow(df2)==df2df1

12.2、常用函数

info[‘x’].max() #获取最大值 info[‘x’].min() #获取最小值 info.mean() #获取均值，获取列的均值

x=np.array([np.arange(5),np.arange(5),np.arange(3,8)]) df=pd.DataFrame(x) print(df.values) print(df.mean()) print(df[0].mean())

img

参考链接

pandas常用函数：https://www.cjavapy.com/article/388/

合并：https://www.jb51.net/article/231326.htm

时间连续性：https://www.cnblogs.com/zcsh/p/14790823.html

agg函数提供的聚合功能允许在一次计算中按组计算多个统计数据。语法很简单，聚合指令以字典或列表的形式提供。