python知识点总结_20211231

导入包

import os
import sys
import time
import shutil
import pickle
import collections
import numpy as np
import pandas as pd
from datetime import datetime
import matplotlib.pyplot as plt
import seaborn as sn


# 打印行、列数量设置
pd.set_option('display.max_columns',200)
pd.set_option('display.max_rows',200)
pd.set_option('display.width',200)

# 画图中文显示
plt.rcParams['font.family'] = ['sans-serif']
plt.rcParams['font.sans-serif'] = ['SimHei']  # 上两句一起设置显示中文
plt.rcParams['axes.unicode_minus'] = False    # 显示负号

# import warnings
# warnings.filterwarnings('ignore')

查看安装包版本

import pip

pip.main(['list'])

sys.path

print (sys.path)

['D:\\01_Wonder\\98_Learning\\99_test_HT2021\\01_Python', 'C:\\Users\\yuhai\\Anaconda3\\envs\\ppt\\python38.zip', 'C:\\Users\\yuhai\\Anaconda3\\envs\\ppt\\DLLs', 'C:\\Users\\yuhai\\Anaconda3\\envs\\ppt\\lib', 'C:\\Users\\yuhai\\Anaconda3\\envs\\ppt', '', 'C:\\Users\\yuhai\\Anaconda3\\envs\\ppt\\lib\\site-packages', 'C:\\Users\\yuhai\\Anaconda3\\envs\\ppt\\lib\\site-packages\\locket-0.2.1-py3.8.egg', 'C:\\Users\\yuhai\\Anaconda3\\envs\\ppt\\lib\\site-packages\\win32', 'C:\\Users\\yuhai\\Anaconda3\\envs\\ppt\\lib\\site-packages\\win32\\lib', 'C:\\Users\\yuhai\\Anaconda3\\envs\\ppt\\lib\\site-packages\\Pythonwin', 'C:\\Users\\yuhai\\Anaconda3\\envs\\ppt\\lib\\site-packages\\IPython\\extensions', 'C:\\Users\\yuhai\\.ipython']

sys.argv

sys.argv[ ]其实就是一个列表，里边的项为用户输入的参数，关键就是要明白这参数是从程序外部输入的，而非代码本身的什么地方，要想看到它的效果就应该将程序保存了，从外部来运行程序并给出参数。

输入：test.py what

输出：[‘test.py’,‘what’]

CSDN: sys.argv

# args = sys.argv 传参
args = ['input_path : 012','output_path : 022']
f1 = filter(lambda arg: ':' in arg, args)   # 筛选列表里面含有指定字符的元素
print (f1)
for i in args:
    print (i)
    
print ('*_'*20)
m1 = map(lambda arg: arg.split(':',1),f1)
print (m1)
for i in m1:
    print (i)

print ('*_'*20)
for i in m1:    # f1与m1迭代一次后就没有内容了
    print (i)
    
d1 = dict(m1)
print (d1)    # 因为m1里面内容已为空
print (dict(map(lambda arg: arg.split(':',1),filter(lambda arg: ':' in arg, args))))

<filter object at 0x000001A635A41400>
input_path : 012
output_path : 022
*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_
<map object at 0x000001A635A415B0>
['input_path ', ' 012']
['output_path ', ' 022']
*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_
{}
{'input_path ': ' 012', 'output_path ': ' 022'}

argparse

从 sys.argv 解析参数

博客园：argparse

引用博客园

parser = argparse.ArgumentParser()
parser.add_argument('--base_path', type=str, help='project base path')
parser.add_argument('--task_nm', type=str, default='20211220')
parser.add_argument('--app_nm', type=str, default='hcv')
parser.add_argument('--model_nm', type=str, default='sarimax')
parser.add_argument('--fit_periods', type=int, default=9)
parser.add_argument('--season_window', type=int, default=12)
parser.add_argument('--val_window', type=int, default=18)
parser.add_argument('--prd_window', type=int, default=5)
parser.add_argument('--data_source', type=str, default='url_sarimax')
args = parser.parse_args()

sys.argv与argparse

import argparse
import time
import sys

print ('hello world1')
time.sleep(2)
# python test_argparse_argv.py --num1 2 --ext aaa -str1 bbb

def main(argv):
    parser = argparse.ArgumentParser()
    parser.add_argument('--num1', type=int, help='a number')
    parser.add_argument('--ext', type=str, default="ext string", help='default value')
    parser.add_argument('-str1', type=str, help='a str')

    args = parser.parse_args()

    print(args.num1)
    print(args.str1)
    print(args.ext)
    print (args)
    print('*_' * 30)
    print (argv)
    print (len(argv))


if __name__ == '__main__':

    print ('hello world4')
    print ('hello world5')
    print ('hello world6')

    print('*_' * 20)
    main(sys.argv)
    time.sleep(5)

makedirs(exist_ok)新建文件夹

log_dir = './test22/'
if log_dir != '':
    os.makedirs(log_dir, exist_ok=True)

列表*args或者字典**kwargs参数解压

可变参数

• 如果我们不确定要往函数中传入多少个参数，或者我们想往函数中以列表和元组的形式传参数时，那就使要用*args；

• *args可以当作可容纳多个变量组成的list;

• 如果我们不知道要往函数中传入多少个关键词参数，或者想传入字典的值作为关键词参数时，那就要使用**kwargs;

• **kwargs可以当作容纳多个key和value的dictionary.

CSDN博客

def func_arg(farg, *args):
    print("formal arg:", farg)
    for arg in args:
        print("another arg:", arg)
func_arg(1,"youzan",'dba','四块五的妞')
print("-----------------------")

formal arg: 1
another arg: youzan
another arg: dba
another arg: 四块五的妞
-----------------------

def func_kwargs(farg, **kwargs):
    print("formal arg:", farg)
    for key in kwargs:
        print("keyword arg: %s: %s" % (key, kwargs[key]))
func_kwargs(1 ,id=1, name='youzan', city='hangzhou',age ='20',四块五的妞是 = '来日方长的')
print('--------------------')

formal arg: 1
keyword arg: id: 1
keyword arg: name: youzan
keyword arg: city: hangzhou
keyword arg: age: 20
keyword arg: 四块五的妞是: 来日方长的
--------------------

collections.deque

双边队列

q = collections.deque([1, 2, 3, 4])
print(5 in q)  # False
print(1 in q)  # True

False
True

# 顺时针
q = collections.deque([1, 2, 3, 4])
q.rotate(1)
print(q)  # [4, 1, 2, 3]
q.rotate(1)
print(q)  # [3, 4, 1, 2]

# 逆时针
q = collections.deque([1, 2, 3, 4])
q.rotate(-1)
print(q)  # [2, 3, 4, 1]
q.rotate(-1)
print(q)  # [3, 4, 1, 2]

deque([4, 1, 2, 3])
deque([3, 4, 1, 2])
deque([2, 3, 4, 1])
deque([3, 4, 1, 2])

q.appendleft(9)
print (q)
q.popleft()
print (q)
q.extendleft([9,10,11])
print (q)

deque([9, 3, 4, 1, 2])
deque([3, 4, 1, 2])
deque([11, 10, 9, 3, 4, 1, 2])

filter

filter(function, iterable)

菜鸟教程

foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]

f1 = filter(lambda x: x % 3 == 0, foo)
print (list(f1))

[18, 9, 24, 12, 27]

map

map(function, iterable, …)

菜鸟教程

map高级用法

lambda

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HbSeZntZ-1644400538411)(./lambda.png)]

博客园: lambda

m1  = map(lambda x: x * 2 + 10, foo)
print (list(m1))

[14, 46, 28, 54, 44, 58, 26, 34, 64]

rjust

list1 = str('abcd')
print (list1)
list2 = list(map(lambda x: x.rjust(3,'0'),list1))
#  rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。
print (list2)

abcd
['00a', '00b', '00c', '00d']

列表元素字符转整形

list1 = ['10','4']
m1=map(int,list1)
print (list(m1))

[10, 4]

给对应资产添加其权重

train_df_min['Weight'] = train_df_min['Asset_ID'].map(asset_details_df.set_index(keys='Asset_ID')['Weight'])

numpy

append

list append

list1 = [1,3,5,8]
list1.append(9)
print (list1)

list1 = list1.append(10)   # 直接在原list上操作，返回为None
print (list1)

[1, 3, 5, 8, 9]
None

array append

# ndarray append
arr1 = np.array([1,3,5,8])
arr1.append(9)              # 不允许在原ndarray上操作

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-104-56c25f7cb4ba> in <module>
      1 # ndarray append
      2 arr1 = np.array([1,3,5,8])
----> 3 arr1.append(9)              # 不允许在原ndarray上操作


AttributeError: 'numpy.ndarray' object has no attribute 'append'

arr1 = np.append(arr1,9)   # 拼接单个标量
print (arr1)
arr2 = np.array([2,4,6,8,10])
# ndarray append的使用，如果后面带axis参数，append维度要一致
arr3 = np.append(arr1,arr2,axis=0)  # 可以在不同维度拼接
print (arr3)

[1 3 5 8 9]
[ 1  3  5  8  9  2  4  6  8 10]

unique&split

按某个索引特值进行切分数据集

unique(return_index)

col1 = ['a','a','b','b','c','c']
col2 = [1,3,2,5,4,6]
col3 = [1,2,3,4,5,6]
df1 = pd.DataFrame(columns=['A','B','C'])
df1['A'] = col1
df1['B'] = col2
df1['C'] = col3
display (df1)

	A	B	C
0	a	1	1
1	a	3	2
2	b	2	3
3	b	5	4
4	c	4	5
5	c	6	6

ids, index = np.unique(df1['A'].values, return_index=True)
print (ids)
print (index)

['a' 'b' 'c']
[0 2 4]

split

df_colnames = ['B','C']
splits = np.split(df1[df_colnames].values, index[1:])
print (splits)

[array([[1, 1],
       [3, 2]], dtype=int64), array([[2, 3],
       [5, 4]], dtype=int64), array([[4, 5],
       [6, 6]], dtype=int64)]

分位数percentile&quantile

分位数（quantile）：把一组按照升序排列的数据分割成n个等份区间并产生n-1个等分点后每个等分点所对应的数据。按照升序排列称作第一至第n-1的n分位数。（注：如果等分点在其左右两个数据的中间，那么该等分点所对应的数就是其左右两数的平均数）。

arr1 = np.random.randn(10)
print (arr1)
print (np.percentile(arr1, 25))  # 25分位数
print (np.percentile(arr1, 50))  # 50分位数
print (np.percentile(arr1, 99.9))  # 99.9分位数
df1 = pd.DataFrame(arr1)
print (df1.quantile(0.999))

[ 1.5951304   0.60237201 -0.8257539  -0.36018484 -2.62652413 -0.26579442
 -0.37066234 -0.38027337  1.43379894 -0.45873811]
-0.4391219223247454
-0.36542358841242295
1.5936784159640822
0    1.593678
Name: 0.999, dtype: float64

savetxt&loadtxt

my_matrix = np.loadtxt(open("D:\\test.csv","rb"), delimiter=",", skiprows=0)

np.savetxt("new.csv", my_matrix, delimiter=',')

average&nan_to_num&nansum&nanmean

• np.nansum: Return the sum of array elements over a given axis treating Not a Numbers (NaNs) as zero.
• np.nanmean

df = pd.DataFrame([1,3,6,8,3],columns=['A'])
df['B'] = [2,1,4,7,9]
weights = np.array([0.4,0.6])
display (df)

df['m'] = np.average(df.fillna(0), axis=1, weights=weights)
display (df)

	A	B
0	1	2
1	3	1
2	6	4
3	8	7
4	3	9

	A	B	m
0	1	2	1.6
1	3	1	1.8
2	6	4	4.8
3	8	7	7.4
4	3	9	6.6

# nan_to_num对数组中缺失值、极值填充
beta = np.nan_to_num(num.T / denom, nan=0., posinf=0., neginf=0.)

tile

a=[0,1,2]   

b=np.tile(a,(3,1))   
b

array([[0, 1, 2],
       [0, 1, 2],
       [0, 1, 2]])

单独返回每一列

# 单独返回每一列
(x[:,i] for i in range(x.shape[1]))

argsort用某一列数据进行排序

# 用某一列数据进行排序
sorted_idx = np.argsort(x[:, asset_id_col_idx])
x = x[sorted_idx]

x=np.array([1,4,3,-1,6,9])
y = x.argsort()
print (y)
print (y[0])
print (x[y])

[3 0 2 1 4 5]
3
[-1  1  3  4  6  9]

expand_dims

weighs = np.array([0.2,0.3,0.5])
print (weighs)
weighs_ = np.expand_dims(weighs,axis=1)
print (weighs_)

[0.2 0.3 0.5]
[[0.2]
 [0.3]
 [0.5]]

每一列分别用权重标准化

a1 = [1,2,3]
a2 = [2,3,4]

# 每一列分别用权重标准化
# np.nansum(Features*np.expand_dims(weigths,axis=1)/np.nansum(weigths),axis=0)
ss0 = np.transpose(np.array([a1,a2]))*weighs_
print (ss0)
ss1 = np.nansum(ss0,axis=0)
print (ss1)
np.tile(ss1,(3,1))

[[0.2 0.4]
 [0.6 0.9]
 [1.5 2. ]]
[2.3 3.3]





array([[2.3, 3.3],
       [2.3, 3.3],
       [2.3, 3.3]])

where

np.isnan

np.isinf

Open = np.array([20,np.nan,40])
weighs = np.where(np.isnan(Open),Open,weighs)
print (weighs)

[0.2 nan 0.5]

shift(freq)&diff&pct_change

shift

DataFrame.shift(periods=1, freq=None, axis=0)

axis：{0, 1, ‘index’, ‘columns’}，表示移动的方向，如果是0或者’index’表示上下移动，如果是1或者’columns’，则会左右移动

df1 = pd.DataFrame(np.random.randint(1,10,(6,2)),columns=list('AB'),
                  index=pd.date_range(start='20220101',periods = 6,freq = '1D'))
display (df1)

	A	B
2022-01-01	7	3
2022-01-02	3	6
2022-01-03	8	5
2022-01-04	1	7
2022-01-05	5	1
2022-01-06	4	7

df1['C'] = df1['A'].shift(1)  # 数据往下偏移
df1['D'] = df1['B'].shift(-1) # 数据往上偏移
display (df1)

	A	B	C	D
2022-01-01	7	3	NaN	6.0
2022-01-02	3	6	7.0	5.0
2022-01-03	8	5	3.0	7.0
2022-01-04	1	7	8.0	1.0
2022-01-05	5	1	1.0	7.0
2022-01-06	4	7	5.0	NaN

display (df1.shift(periods=1,freq='-1D'))  # 时间索引往上偏移
display (df1.shift(periods=1,freq='2D'))   # 时间索引往下偏移

	A	B	C	D
2021-12-31	7	3	NaN	6.0
2022-01-01	3	6	7.0	5.0
2022-01-02	8	5	3.0	7.0
2022-01-03	1	7	8.0	1.0
2022-01-04	5	1	1.0	7.0
2022-01-05	4	7	5.0	NaN

	A	B	C	D
2022-01-03	7	3	NaN	6.0
2022-01-04	3	6	7.0	5.0
2022-01-05	8	5	3.0	7.0
2022-01-06	1	7	8.0	1.0
2022-01-07	5	1	1.0	7.0
2022-01-08	4	7	5.0	NaN

diff

numpy.diff(a, n=1,axis=-1)

• a 表示需要进行差分操作的数据
• n 代表执行几次差值
• axis：默认是-1。

dataframe.diff(periods,axis)

• dataframe：可以是直接对dataframe结构进行diff，也可以是Series，另外还可以是进行聚合或者其他操作之后的Series
• periods：表示移动的幅度。它是任意整数，如果是想让数据统一向下移动n个periods，则n为正，如果是想让数据向上移动n个periods，则n为负
• axis：表示参考轴。如果axis=0，则是进行行间的移动差分操作，如果axis=1，则进行列间的移动差分操作。

df1['E'] = df1['A'].diff(2)
df1['F'] = df1['A'].diff(-2)
display (df1)

	A	B	C	D	E	F
2022-01-01	7	3	NaN	6.0	NaN	-1.0
2022-01-02	3	6	7.0	5.0	NaN	2.0
2022-01-03	8	5	3.0	7.0	1.0	3.0
2022-01-04	1	7	8.0	1.0	-2.0	-3.0
2022-01-05	5	1	1.0	7.0	-3.0	NaN
2022-01-06	4	7	5.0	NaN	3.0	NaN

pct_change

python如何计算环比增长率

df1['G'] = df1['A'].pct_change()
df1

	A	B	C	D	E	F	G
2022-01-01	7	3	NaN	6.0	NaN	-1.0	NaN
2022-01-02	3	6	7.0	5.0	NaN	2.0	-0.571429
2022-01-03	8	5	3.0	7.0	1.0	3.0	1.666667
2022-01-04	1	7	8.0	1.0	-2.0	-3.0	-0.875000
2022-01-05	5	1	1.0	7.0	-3.0	NaN	4.000000
2022-01-06	4	7	5.0	NaN	3.0	NaN	-0.200000

group&apply

reindex

多重索引删除

input_df_min = input_df_min.groupby('Asset_ID',as_index=False).apply(lambda x: x.reindex(range(x.index[0],x.index[-1]+60,60),method='pad'))
input_df_min.reset_index(level=0, inplace=True, drop=True)

glob

glob模块的主要方法就是glob,该方法返回所有匹配的文件路径列表（list）

CSDN: glob

• "*"匹配0个或多个字符；
• "?"匹配单个字符；
• "[]"匹配指定范围内的字符，如：[0-9]匹配数字。

import os
import shutil

local_path = os.getcwd()
dirname = 'test_file'

if dirname in os.listdir(local_path):
#     os.rmdir(dirname) # 只能删除空目录
    shutil.rmtree(dirname)
    
os.mkdir(dirname)
full_path = local_path + '\\'+dirname
print (full_path)

def text_create(full_path, name, msg):
#     local_path = os.getcwd()
    file_path = full_path  + '\\'+ name  + '.txt'  
    file = open(file_path, 'w+')
    file.write(msg)   
    file.close()
    
for name in ['file1','file2','file3']:
    text_create(full_path,name,name)

print (os.listdir(full_path))

from glob import glob

path_pattern = '{}\*.txt'.format(full_path)
for name in glob(path_pattern):
    print (name)

D:\01_Wonder\98_Learning\99_test_HT2021\01_Python\test_file
['file1.txt', 'file2.txt', 'file3.txt']
D:\01_Wonder\98_Learning\99_test_HT2021\01_Python\test_file\file1.txt
D:\01_Wonder\98_Learning\99_test_HT2021\01_Python\test_file\file2.txt
D:\01_Wonder\98_Learning\99_test_HT2021\01_Python\test_file\file3.txt

findall

获取字符串中所有匹配的字符串，返回一个列表

CSDN: re.findall

import re
x=re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
print(x)

['foot', 'fell', 'fastest']

reduce迭代计算

首先把 前两个元素传给 函数参数，函数加工后，然后把得到的结果和第三个元素作为两个参数传给函数参数， 函数加工后得到的结果又和第四个元素作为两个参数传给函数参数，依次类推。 如果传入了 initial 值， 那么首先传的就不是 sequence 的第一个和第二个元素，而是 initial值和 第一个元素。经过这样的累计计算之后合并序列到一个单一返回值。

博客园: reduce

print (foo)

[2, 18, 9, 22, 17, 24, 8, 12, 27]

from functools import reduce
print (reduce(lambda x, y: x*10 + y, foo))

391394947

def add(x, y):
    return x+y
reduce(add, [1,2,3,4])

10

cumsum

累加

df1 = pd.DataFrame(np.random.randint(1,5,(5,2)),columns=list('AB'))
df1

	A	B
0	1	4
1	1	3
2	4	4
3	2	3
4	4	3

df1['C'] = df1['B'].cumsum() 
df1

	A	B	C
0	1	4	4
1	1	3	7
2	4	4	11
3	2	3	14
4	4	3	17

pandas一列转字典dict_weights

dict_weights = dict(asset_details_df.set_index('Asset_ID')['Weight'])

string

split

str.split(str="", num=string.count(str))

• str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
• num – 分割次数。默认为 -1, 即分隔所有。

str1 = 'abdcdbca'
print (str1.split('c',0))
print (str1.split('c',1))
print (str1.split('c',2))

['abdcdbca']
['abd', 'dbca']
['abd', 'db', 'a']

dict、zip

str.upper、swapcase

str1 = 'abcdefg'
str_upper = str1.upper()
str_upper = str_upper.swapcase()
str_ids = range(len(str_upper))
n_dict = dict(zip(str_ids, str_upper))
print (n_dict) 

{0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e', 5: 'f', 6: 'g'}

str.replace

'2022-02-08'.replace('-','')

'20220208'

字符串格式化

dict_info = {'name':'Jone',
            'age':24}
print ('%(name)s age is %(age)d, %(name)s is young!'%dict_info)
print ('{name} age is {age}, {name} is young!'.format(**dict_info))

Jone age is 24, Jone is young!
Jone age is 24, Jone is young!

age = 24
name = 'Hayden'
print (f'{name} age is {age}, {name} is young!')

Hayden age is 24, Hayden is young!

sort_values、set_index、reset_index、drop_duplicates

train_df_min.sort_values('timestamp',ascending=True,inplace=True)

train_df_min.set_index(keys=['td_time'], inplace=True)

train_df_min.reset_index(inplace=True)

x_train_df2.reset_index().drop_duplicates('timestamp',keep='first').set_index('timestamp')

transpose、T、swapaxes

transpose转换坐标轴

x = np.arange(4).reshape((2,2))
display (x)
display (np.transpose(x)) # 对于二维 ndarray，transpose在不指定参数是默认是矩阵转置。
display (x.T)

array([[0, 1],
       [2, 3]])



array([[0, 2],
       [1, 3]])



array([[0, 2],
       [1, 3]])

transpose与swapaxes

arr = np.arange(24).reshape((2, 3, 4))
display (arr)

array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])

arr1 = arr.transpose((0, 2, 1))
display (arr1)
display (arr)

array([[[ 0,  4,  8],
        [ 1,  5,  9],
        [ 2,  6, 10],
        [ 3,  7, 11]],

       [[12, 16, 20],
        [13, 17, 21],
        [14, 18, 22],
        [15, 19, 23]]])



array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])

arr2 = arr.swapaxes(1, 2)
display (arr2)
display (arr)

array([[[ 0,  4,  8],
        [ 1,  5,  9],
        [ 2,  6, 10],
        [ 3,  7, 11]],

       [[12, 16, 20],
        [13, 17, 21],
        [14, 18, 22],
        [15, 19, 23]]])



array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])

stack、pivot

• stack:将数据的列索引旋转为行索引

• unstack:将数据的行索引旋转为列索引

• pivot(index,columns,values)：将index指定为行索引，columns是列索引，values则是DataFrame中的值

df = pd.DataFrame({'水果':['苹果','梨','草莓'],
               '数量':[3,4,5],
               '价格':[4,5,6]})
display (df)

stack_df = df.stack()
print (type(stack_df))
display (stack_df)

unstack_df = stack_df.unstack()
display(unstack_df)
display (unstack_df.T)

# 通过level参数指定旋转轴的层次(默认level=-1)
unstack_df2 = stack_df.unstack(level=0)
display(unstack_df2)

	水果	数量	价格
0	苹果	3	4
1	梨	4	5
2	草莓	5	6

<class 'pandas.core.series.Series'>



0  水果    苹果
   数量     3
   价格     4
1  水果     梨
   数量     4
   价格     5
2  水果    草莓
   数量     5
   价格     6
dtype: object

	水果	数量	价格
0	苹果	3	4
1	梨	4	5
2	草莓	5	6

	0	1	2
水果	苹果	梨	草莓
数量	3	4	5
价格	4	5	6

	0	1	2
水果	苹果	梨	草莓
数量	3	4	5
价格	4	5	6

pivot

df = pd.DataFrame({'水果种类':['苹果','苹果','梨','梨','草莓','草莓'],
               '信息':['价格','数量','价格','数量','价格','数量'],
               '值':[4,3,5,4,6,5]})
display (df)

display(df.pivot('水果种类','信息','值'))

# pivot可以用set_index和unstack等价的实现
display(df.set_index(['水果种类','信息']).unstack())

	水果种类	信息	值
0	苹果	价格	4
1	苹果	数量	3
2	梨	价格	5
3	梨	数量	4
4	草莓	价格	6
5	草莓	数量	5

信息	价格	数量
水果种类
梨	5	4
苹果	4	3
草莓	6	5

	值
信息	价格	数量
水果种类
梨	5	4
苹果	4	3
草莓	6	5

pandas取多级列名 get_level_values

df2_read.columns.get_level_values(1)

itertools参数组合

import itertools
p_values = range(0, 3)
d_values = range(0, 2)
q_values = range(0, 3)

P_values = range(0, 3)
D_values = range(0, 2)
Q_values = range(0, 3)

periods = [12]

parameters = itertools.product(p_values, d_values, q_values, P_values, D_values, Q_values, periods)
parameters_list = list(parameters)
print (len(parameters_list))

324

enumerate()

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中

list1 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list1):
    print (index, item)

0 这
1 是
2 一个
3 测试

enumerate还可以接收第二个参数，用于指定索引起始值

for index, item in enumerate(list1,1):
    print (index, item)

1 这
2 是
3 一个
4 测试

clip

df = pd.DataFrame(np.random.randn(4,3),columns=list('ABC'))
display (df)
df['D'] = df['C'].clip(df['A'],df['B']) # 下限和上限阈值
df

	A	B	C
0	-2.282445	1.916817	-0.473631
1	1.587007	2.609682	-0.261425
2	-1.039210	0.746001	0.954572
3	-0.057547	-0.770710	-0.230408

	A	B	C	D
0	-2.282445	1.916817	-0.473631	-0.473631
1	1.587007	2.609682	-0.261425	1.587007
2	-1.039210	0.746001	0.954572	0.746001
3	-0.057547	-0.770710	-0.230408	-0.770710

日期

time.strftime("%Y%m%d")

'20220208'

time.strftime("%Y%m%d %X")

'20220208 16:11:36'

ceil、floor、int、round、sign

import math
a = 1.23
b = 1.99

print ('*_'*10,'ceil','*_'*10)
print (math.ceil(a))   # 向上取整
print (math.ceil(b))
print (math.ceil(-a))
print (math.ceil(-b))

print ('*_'*10,'floor','*_'*10)
print (math.floor(a))   # 向下取整
print (math.floor(b))
print (math.floor(-a))
print (math.floor(-b))

print ('*_'*10,'int','*_'*10)
print (int(a))           # 取整数部位
print (int(b))
print (int(-a))
print (int(-b))

print ('*_'*10,'round','*_'*10)
print (round(a))         # 四舍五入
print (round(b))
print (round(-a))
print (round(-b))

print ('*_'*10,'sign','*_'*10)
arr1 = [a,b,0,-a,-b]
print (np.sign(arr1))  # 符号函数

*_*_*_*_*_*_*_*_*_*_ ceil *_*_*_*_*_*_*_*_*_*_
3
2
-2
-1
*_*_*_*_*_*_*_*_*_*_ floor *_*_*_*_*_*_*_*_*_*_
2
1
-3
-2
*_*_*_*_*_*_*_*_*_*_ int *_*_*_*_*_*_*_*_*_*_
2
1
-2
-1
*_*_*_*_*_*_*_*_*_*_ round *_*_*_*_*_*_*_*_*_*_
2
2
-2
-2
*_*_*_*_*_*_*_*_*_*_ sign *_*_*_*_*_*_*_*_*_*_
[ 1.  1.  0. -1. -1.]

locals()字典的形式返回变量

• 如果在函数内部使用 locals()，那么会以字典的形式返回函数内部定义的变量。
• 如果在函数外部使用 locals()，那么会以字典的形式返回全局变量和内置变量。

locals

locals()

# locals()更新字典值，跟普通字典一样
# locals()[键] = 新值
locals()['a'] = 2.235

locals()['df1']

	A	B	C	D
0	1	4	4	NaN
1	1	3	7	NaN
2	4	4	11	NaN
3	2	3	14	NaN
4	4	3	17	NaN

PyPolars&datatable

提升计算速度，当数据对于Pandas而言太大、对于Spark而言太小时，使用 PyPolars。

PyPolars库有两个API，一个是Eager API，另一个是Lazy API。Eager API与Pandas的API非常相似，执行完成后立即获得结果，这类似Pandas。Lazy API与Spark非常相似，一执行查询，就形成地图或方案。然后在CPU的所有核心上并行执行。

• datatable替代pandas

interpolate()插值

# interpolate()插值
dfs = {asset_id: df[df['Asset_ID'] == asset_id].resample('1min').interpolate().copy() for asset_id in df['Asset_ID'].unique()}

时间间隔计数value_counts

test_data.sort_index(ascending=True).groupby('Asset_ID').apply(lambda x: (x.index[1:]-x.index[:-1]).value_counts())

神经网络模型保存与加载

model.save('mlp_ae.h5') 
new_model = tf.keras.models.load_model('mlp_ae.h5')