pandas常用方法总结

发表于 | 更新于 | 分类于 | 阅读次数：

to_dict(将dataframe转换成字典格式)===对应的为json格式(十分常用)

常用的有records和index

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import pandas as pd
import numpy as np
df = pd.DataFrame(np.arange(12).reshape(3,4),columns=['A','B','C','D'])
df
    A   B   C   D
0   0   1   2   3
1   4   5   6   7
2   8   9   10  11
df.to_dict('records')    # 使用频繁
[{'A': 0, 'B': 1, 'C': 2, 'D': 3},
 {'A': 4, 'B': 5, 'C': 6, 'D': 7},
 {'A': 8, 'B': 9, 'C': 10, 'D': 11}]
df.to_dict('index')   # 使用频繁，一般报表的横坐标为日期，将date作为Index
{0: {'A': 0, 'B': 1, 'C': 2, 'D': 3},
 1: {'A': 4, 'B': 5, 'C': 6, 'D': 7},
 2: {'A': 8, 'B': 9, 'C': 10, 'D': 11}}

次要的有dict(默认)\list\series\split都必须掌握

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
29
30
31
32
33
34
35
36
import pandas as pd
import numpy as np
df = pd.DataFrame(np.arange(12).reshape(3,4),columns=['A','B','C','D'])
df
    A   B   C   D
0   0   1   2   3
1   4   5   6   7
2   8   9   10  11
df.to_dict('dict')   # 默认是dict
{'A': {0: 0, 1: 4, 2: 8},
 'B': {0: 1, 1: 5, 2: 9},
 'C': {0: 2, 1: 6, 2: 10},
 'D': {0: 3, 1: 7, 2: 11}}

df.to_dict('list') 
{'A': [0, 4, 8], 'B': [1, 5, 9], 'C': [2, 6, 10], 'D': [3, 7, 11]}

df.to_dict('series') 
{'A': 0    0
 1    4
 2    8
 Name: A, dtype: int64, 'B': 0    1
 1    5
 2    9
 Name: B, dtype: int64, 'C': 0     2
 1     6
 2    10
 Name: C, dtype: int64, 'D': 0     3
 1     7
 2    11
 Name: D, dtype: int64}

df.to_dict('split')
{'index': [0, 1, 2],
 'columns': ['A', 'B', 'C', 'D'],
 'data': [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]}

astype(强制数据类型转换)

1
df['A'] = df['A'].astype(float)

group_by(分组)

1
2
3
4
5
6
7
8
9
10
11
12
(如果groupby后并sum,如果存在数字求和,则其他类型组合会清除,如果不存在数字求和,则字符串会出现拼接效果,如下所示)====通常的group都是与apply一起使用的,需要进一步了解
df = pd.DataFrame([['0',1,'boy','3'],['0','5','girl','7']], columns=['A','B','C','D'])
df

	A	B	C	 D
0	0	1	boy	 3
1	0	5	girl 7
df.groupby('A').sum()
df
	C	    D
A		
0  boygirl	37

map\applymap\apply用法

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
29
30
map===将series中的每一个元素通过函数进行处理(常用于dataframe中数据某一个字段整体的清洗)
df1 = pd.DataFrame([['a','b','c'],['d','e','f']],columns=['A','B','C'])
df1
	A	B	C
0	a	b	c
1	d	e	f
df1['A'] = df1['A'].map(lambda x:x+'号')
df1
	A	B	C
0	a号	b	c
1	d号	e	f


applymap对于dataframe中的每一个元素进行操作
df1.applymap(lambda x:x+'球')
	  A	   B    C
0	a号球	b球	c球
1	d号球	e球	f球


apply方法可选定对于dataframe中行或者列进行操作
df1.apply(lambda x:x.sum(),axis=0)
A    a号d号
B      be
C      cf
dtype: object
df1.apply(lambda x:x.sum(),axis=1)
0    a号bc
1    d号ef
dtype: object

dataframe索引操作

reset_index

1
2
3
4
5
6
7
8
9
10
11
12
13
14
重置行索引(若果不加drop=True,则原来的索引成为新的列,加上则替换原索引)
df1.index = ['s','b']
df1
	A	B	C
s	a号	b	c
b	d号	e	f
df1.reset_index(drop=True)
	A	B	C
0	a号	b	c
1	d号	e	f
df1.reset_index()
  index	 A	 B	 C
0	s	a号	b	c
1	b	d号	e	f

reindex

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
重构或者任意重排索引,没有的数据会显示nan
df = pd.DataFrame(np.random.randint(1,100,(5,5)))
df
	0	1	2	3	4
0	94	14	86	30	9
1	94	19	7	29	40
2	53	7	45	57	18
3	71	75	56	53	36
4	96	11	92	97	53
df.reindex([4,2,3,5])
	 0	       1	 2	      3	      4
4	96.0	11.0	92.0	97.0	53.0
2	53.0	7.0	    45.0	57.0	18.0
3	71.0	75.0	56.0	53.0	36.0
5	 NaN	NaN 	NaN	     NaN	NaN

rename

1
df.rename(columns=lambda x: x + 1)：批量更改列名

数据处理相关

fillna补值

1
2
3
4
5
6
7
8
9
10
#直接替换原数据的nan为0,不加inplace不对原数据操作
df.fillna(0,inplace=True)
#通过字典对不同的列填充不同的常数
df1.fillna({0:10,1:20,2:30})
#用前面的值来填充
df2.fillna(method='ffill')
#用后面的值来填充
df2.bfill(method='bfill')
#limit限制填充的个数,axis修改填充的方向
df2.fillna(method="ffill",limit=1,axis=1)

dropna删除空值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
df.dropna(how='')  all删除全为空值那一行,any删除存在空值那一行(默认0表示行,1代表列)
DataFrame.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)
参数说明：

axis:
axis=0: 删除包含缺失值的行
axis=1: 删除包含缺失值的列
how: 与axis配合使用
how=‘any’ :只要有缺失值出现，就删除该行货列
how=‘all’: 所有的值都缺失，才删除行或列
thresh： axis中至少有thresh个非缺失值，否则删除
比如 axis=0，thresh=10：标识如果该行中非缺失值的数量小于10，将删除改行
subset: list
在哪些列中查看是否有缺失值
inplace: 是否在原数据上操作。如果为真，返回None否则返回新的copy，去掉了缺失值

unique去重(针对series的去重)

1
df['A'].unique()

drop_duplicates(针对dataframe去重也可series)====实质针对的是所有的列字段

1
2
3
4
全部字段
df.drop_duplicates()
指定字段
df.drop_duplicates(['colA', 'colB'])

replace替换指定字符

1
2
df.replace(np.nan,0,inplace=True)
将所有的空值替换成0

describe\info

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
查看汇总统计
df.describe()
			0			1			2			3			4
count	4.000000	4.000000	4.000000	4.000000	4.00000
mean	55.000000	23.250000	48.250000	51.750000	26.75000
std	40.685788	34.798228	37.915476	39.811012	22.85279
min	0.000000	0.000000	0.000000	0.000000	0.00000
25%	39.750000	5.250000	33.750000	39.750000	13.50000
50%	62.000000	9.000000	50.500000	55.000000	27.00000
75%	77.250000	27.000000	65.000000	67.000000	40.25000
max	96.000000	75.000000	92.000000	97.000000	53.00000

查看索引、数据类型和内存信息
df.info()
<class 'pandas.core.frame.DataFrame'>
Int64Index: 4 entries, 4 to 6
Data columns (total 5 columns):
0    4 non-null float64
1    4 non-null float64
2    4 non-null float64
3    4 non-null float64
4    4 non-null float64
dtypes: float64(5)
memory usage: 192.0 bytes

数据合并merge\concat\join

1
2
3
4
pd.merge(df1, df2, on='key', how='left')
pd.concat([df1,df2],join="inner",axis=1)===不会去重
pd.concat([df1,df2],ignore_index=True).drop_duplicates() ====会去重
df1.join(df2,how='inner')

date_range 创建时间数据

1
2
3
4
5

pd.date_range('2018-09-10',periods=8,freq='m')
DatetimeIndex(['2018-09-30', '2018-10-31', '2018-11-30', '2018-12-31',
               '2019-01-31', '2019-02-28', '2019-03-31', '2019-04-30'],
              dtype='datetime64[ns]', freq='M')

value_counts数据频数统计

1
2
3
4
5
6
7
8
对某一行或者某一列数据进行频数统计
df.loc[2].value_counts()
7.0     1
额外请问    1
45.0    1
57.0    1
18.0    1
Name: 2, dtype: int64

数据统计

1
2
3
4
5
6
7
8
df.describe()：查看数据值列的汇总统计
df.mean()：返回所有列的均值
df.corr()：返回列与列之间的相关系数
df.count()：返回每一列中的非空值的个数
df.max()：返回每一列的最大值
df.min()：返回每一列的最小值
df.median()：返回每一列的中位数
df.std()：返回每一列的标准差

数据选取(isin和str.contains)

isin(df和series都可用)

1
2
3
4
5
6
7
8
9
10
11
判断是否含所有某个数据(完全匹配)等于多个数值或者字符串时  内容为列表格式--符合任意一个都会返回
df
	0		1		2		3		4
4	委屈翁	11.0	92.0	97.0	53.0
2	额外请问	7.0	45.0	57.0	18.0
3	问问	75.0	56.0	53.0	36.0
6	委屈翁群	0.0	0.0	0.0	0.0
df[0][df[0].isin(['委屈翁','问问'])]
4    委屈翁
3     问问
Name: 0, dtype: object

str.contains(针对的为series)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
判断某个数据中是否包含指定字符(字符串的模糊筛选)
df[0][df[0].str.contains('委屈')]
4     委屈翁
6    委屈翁群
Name: 0, dtype: object
多条件筛选用|符号
df[0][df[0].str.contains('翁|问')]
4     委屈翁
2    额外请问
3      问问
6    委屈翁群
Name: 0, dtype: object
        
 #参数解释    
Series.str.contains(
                    pat,        # 要查询的字符串、要查询的或者正则表达式
                    case=True,  # 是否对大小写敏感
                    flags=0,    # 用来传给正则模块的参数，比如 flags=re.INGNORECASE 等价于 case=False
                    na=nan,     # 默认对空值不处理，即输出结果还是 NaN
                    regex=True  # 即第一个参数 pat部分 要不要按照正则表达式的规则。
                                 #所以针对特殊符号，默认情况下我们必须使用转义符，或者设置 regex=False
                    )
set_index 和 reset_index
1
2
3
4
5
6
7
8
将df1中A这一列设为索引,并且不删除原来的A那一列
df1.set_index('A',drop=False)
将df1中A这一列设为索引,并且删除原来的A那一列
df1.set_index('A',drop=True)
将df1中的索引还原,并且添加一列新的列(原来的索引列)
df1.reset_index('A',drop=False)
将df1中的索引重置,索引那一列直接删除
df1.reset_index('A',drop=True)
rank
1
2
3
4
5
df.rank()  #默认按照列排序,返回的结果为对应各自排名的矩阵
df.rank(axis=1) #按照行进行排序
df.rank(axis=1,method='average') #数据相同的排名全部取对应排名的平均值
df.rank(axis=1,method='max') #取最大排名
df.rank(axis=1,method='first') 原始数据中出现的顺序进行排名
1
2
sorted(cxy_data, key=lambda i: i['num'], reverse=True)  按照字典中的某个值倒叙
sorted(dict1.items(),key=lambda i:i[1])  按照字典的值排序

#####to_excel

1
2
3
writer = pd.ExcelWriter(r'C:\Users\Administrator\Desktop\ceshe.xlsx')
data.to_excel(writer,sheet_name='Sheet1')
writer.save()    #直接将df导出到excel中

#####stack和unstack
stack和unstack

pandas分行取top多少
1
2
3
4
5
6
7
8

Series.nlargest([n, 保持])

返回最大的n 个元素。

Series.nsmallest([n, 保持])

返回最小的n 个元素。

Python操作excel方法 对比

bdf6b66e3614a73cab83cc34ae864063

优化方法

1
2
3
4
5
6
7
df.eval(
    """
    c = a + b
    d = a + b + c
    a = 1
    """,inplace=False)
df.query("strings == 'a' and nums == 1")
等长列表两两元素操作
1
list(map(lambda x :x[0]+x[1] ,zip(a,b)))

传参

1
2
3
outer_params = [company_table,zl_zu_table,replace_rate_group_table,techonology_life_replace_table,zhibiao]
outer_params = ' '.join(outer_params)
os.system(f"python3 tech_life_grant_ceased_num_2.py {outer_params}")

dataframe插入clickhouse

1
2
3
4
client = Client(host='192.168.0.170', port='9000', user='algorithm', password='1a2s3d4f', database='algorithm_dis',settings={'use_numpy': True})

sql_insert = 'insert into industryid_name_20211208 values'
client.insert_dataframe(sql_insert,df)

transform

1
2
3
4
5
超级好用,支持在原有基础上新增一列,支持groupby后的操作

hold_df.groupby(['PORT_ID','SEC_ID','VALID_DATE']).REAL_SEC_ID.transform('count')

transform相当于新增了一列,好东西

shift

1
2
整体向下平移,支持groupby后shift,搭配assigh使用
group.assign(PRE_NAV=(group.groupby( ['GROUP_ID'] + ['GROUP_NAME'] + ['SEC_ID'] + ['SEC_ABBR'])['ADJ_NAV'].shift(1)))

python离线安装第三方whl文件

1
2
3
4
5
6
7
pip download pandas -d  E:\光大POC\fin_indicators


# download online
pip download package_name -d target_dir
# install offline
pip install --no-index -f target_dir -r requirements.txt

其他

1
2
pip freeze > requirments.txt
pip download -d py_pkgs -r requirments.txt

从windows到linux部署

image-20230825160339198

内存回收

1
2
3
数据使用的进程不销毁,占用的内存不会减少,因而可以通过创建子进程实现回收
with concurrent.futures.ProcessPoolExecutor(max_workers=1) as executor:
    result = executor.submit(func).result()

转换数类型神器

df.convert_dtypes

补充:其他的常用方

法总结https://www.cnblogs.com/rexyan/p/7975707.html