文章目录
- 导入包
- 查看安装包版本
- sys.path
- sys.argv
- makedirs(exist_ok)新建文件夹
- 列表\*args或者字典\**kwargs参数解压
- collections.deque
- filter
- map
- numpy
- shift(freq)&diff&pct_change
- group&apply
- glob
- findall
- reduce迭代计算
- pandas一列转字典dict_weights
- string
- sort_values、set_index、reset_index、drop_duplicates
- transpose、T、swapaxes
- stack、pivot
- pandas取多级列名 get_level_values
- itertools参数组合
- enumerate()
- clip
- 日期
- ceil、floor、int、round、sign
- locals()字典的形式返回变量
- PyPolars&datatable
- interpolate()插值
- 时间间隔计数value_counts
- 神经网络模型保存与加载
导入包
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’]
# 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 解析参数
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.
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, …)
lambda
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HbSeZntZ-1644400538411)(./lambda.png)]
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
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)
- "*"匹配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
获取字符串中所有匹配的字符串,返回一个列表
import re
x=re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
print(x)
['foot', 'fell', 'fastest']
reduce迭代计算
首先把 前两个元素传给 函数参数,函数加工后,然后把得到的结果和第三个元素作为两个参数传给函数参数, 函数加工后得到的结果又和第四个元素作为两个参数传给函数参数,依次类推。 如果传入了 initial 值, 那么首先传的就不是 sequence 的第一个和第二个元素,而是 initial值和 第一个元素。经过这样的累计计算之后合并序列到一个单一返回值。
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()['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')