量化金融分析师学习笔记——中篇完结

numpy

#numpy
import numpy as np
print('numpy创建的维度：等于[]个数')
f1=np.array([1,2,3])
print(f1.shape)#(3,)
f2=np.array([[1,2,3]])
print(f2.shape)#(1, 3)
f3=np.array([[1],[2],[3]])
print(f3.shape)#(3, 1)
print(f3.ndim)#2维度
print(f3.dtype)#int32数据类型
print(f3.size)#3元素数量，等于shape中的各个维度值之积
print(f3.itemsize)#4每个元素字节长度
print(f3.nbytes)#12整个数组字节长度，等于size*itemsize

print('numpy与list')
print('切片索引')
a=[1,2,3]
b=[4,5,6]
c=[7,8,9]
d=[a,c,b]
print(d[0:2][0:2])##相当于f=e[0:2]再求f[0:2]
#print(d[0:2,0:2])#报错
e=np.array(d,dtype=np.float64)#创建时定类型
print(e[0:2][0:2])#相当于f=e[0:2]再求f[0:2]
print(e[0:2,0:2])#可以执行行列选取
'''
[[1, 2, 3], [7, 8, 9]]
[[1 2 3]
 [7 8 9]]
[[1 2]
 [7 8]]
'''
print('条件选择')
a=[1,2,3]
b=['a','b','c']
#c=b[a>1]#报错
a=np.array([1,2,3])
b=np.array(['a','b','c'])
c=b[a>1]
print(c)#['b' 'c']
print('调用(默认都是指针)')
a=[11,22]
b=a
c=a.copy()
a[0]=4
print(a,b,c)#[4, 22] [4, 22] [11, 22]
a=np.array([11,22])
b=a
c=a.copy()
a[0]=4
print(a,b,c)#[ 4 22] [ 4 22] [11 22]

print('numpy构造函数')
b1=np.zeros((2,3))#2x3矩阵全零，注意一定要传入元组
b2=np.eye(2)#2x3矩阵对角是一，这里只能传入一个参数
b3=np.empty((2,3))#2x3矩阵全零
b4=np.ones((2,3))#2x3矩阵全一
b5=np.ones_like(b1)#同b1的形状创建全部1
b6=np.linspace(1,4,4)#[1. 2. 3. 4.]
b7=np.arange(1,4,1)#[1 2 3]

print('numpy股票分析常用统计运算')
a=np.array([1,3,2,4,5])
print(a.var())#2.0方差
print(a.std())#1.414标准差
print(a.sum())#15总和
print(a.mean())#3.0均值
print(a.cumsum())#[ 1  4  6 10 15]前缀和
print(a.min())#1最小值
print(a.max())#5最大值
print(a.argmin())#0最小值下标
print(a.argmax())#4最大值下标
print(a.cumprod())#[  1   3   6  24 120]前缀积

print('numpy股票分析常用集合运算')
x=np.array([1,3,2,3,1])
y=np.array([2,3,4,3,2])
print(np.unique(a))#[1 2 3 4 5]只出现一次的值
print(np.intersect1d(x,y))#[2 3]交值
print(np.union1d(x,y))#[1 2 3 4]#并值
print(np.in1d(x,y))#[False  True  True  True False]x元素是否存在于y
print(np.setdiff1d(x,y))#[1]不存在于y的x元素
print(np.setxor1d(x,y))#[1 4]不存在于y的x元素与不存在于x的y元素

print('numpy股票分析常用矩阵运算')
a=[1,2,3]
print(a*2)#[1, 2, 3, 1, 2, 3]这个是List的*运算
b=np.array(a)
print(np.hstack((b,2*b)))#[1 2 3 2 4 6]用hstack水平合并，vstack是列合并
print(b*2)#[2 4 6]这个是numpy的*运算
c=list(b)#numpy转List
print([i*2 for i in b])#[2, 4, 6]for循环实现
print(np.sqrt(b))#[1. 1.414 1.732]
a=np.array([[1,2],[3,4]])
print(a.sum(axis=0))#[4 6]，注意降维了shape是（2，0）
print(a.sum(axis=1))#[3 7]，注意降维了shape是（2，0）

print('numpy随机函数')
np.random.seed(10)#定住每次的随机数
a=np.random.choice(5,10)
a=np.random.randn(2,3)#生成随机矩阵
a=np.random.random((2,3))#生成随机矩阵，与上一行等价，只是传参不同
a=np.random.rand(2,3)#生成随机矩阵，且具有正态分布地生成
a=np.random.standard_normal((2,3))#生成随机矩阵，与上一行等价，只是传参不同
print(a)
print(a.T,a.transpose())#转置
print(len(a))#2长度得到的是最高维
print(np.where(a>0,1,-1))#条件，true赋值，false赋值
print(np.sign(a))#作用同上

print('numpy线性代数函数')
a=np.array([[3,1],[1,2]])
b=np.array([9,8])
x=np.linalg.solve(a,b)
print(x)#[2. 3.]
a=np.array([1,2,3,4,5])
b=np.array([7,12,17,22,27])
c=np.polyfit(a,b,1)
print(c)#[5. 2.]
d=np.polyval([2,6,9],1)#求2*x*x+6*x+9值，x=1
print(d)#17



#补充测试
import numpy as np
a=np.array([[[1],[2],[3]],[[4],[5],[6]]])
print(a.shape)
print(a[0],a[1],sep='\n')

print('------')

a=a.T
print(a.shape)
print(a)

print('------')

a=a.reshape(3,2,1)
print(a.shape)
print(a)

'''
a=a.reshape(3,2,1)
print(a.shape)
print(a[0],a[1],a[2],sep='\n')
若不T再reshape，则231reshape后是123,456改成321是12,34,56而不是14,25,36
'''

pandas

#pandas
#三大数据结构
#series：含xy标签numpy一维向量
#dataframe：多个series，每一列就是一个series
#panel：多个dataframe
import pandas as pd
import numpy as np
df=pd.Series(range(10,20),index=pd.date_range('2017-1-1',periods=10,freq='D'))
print(type(df),df,df[3],type(df.values),df.values,sep='\n',end='\n\n下面开始dataframe\n')

#dataframe
df=pd.DataFrame(np.zeros((2,3)),columns=['g','j','l'],index=['c','j'])
df.loc['c',1:3]=1#第'c'即第0行，第1，2列
df.loc[1:2]=2#就是j行，第一行
df.loc['j','j']=3#第'j'行第'j'列
df.loc[0:1,'g':'j']=4#用标签不是下标也能切片
df.loc[1:2,2:3]=5#即使访问某一位置也应用切片
df['love']=[13,14]#取一个series并赋值，没有则追加
df.rename(columns={'g':'G'},inplace=True)#改标签
df.rename(index={'c':'C'},inplace=True)#改标签
print(type(df),df,type(df.values),df.values,sep='\n',end='\n')#值
print(df.index,df.columns,df.dtypes,df.sum(),sep='\n',end='\n')#属性
print(df,df+df,df-df,df.apply(lambda x:x*x),sep='\n',end='\n')#操作
print(df[(df.G>3)*1+(df.love>10)*1>1],sep='\n',end='\n')#选股
print(df.sort_index(axis=0,ascending=False),sep='\n',end='\n')#先j后C，降序
print(df.sort_index(axis=1,ascending=False),sep='\n',end='\n')#先love后G，降度
del df['love']#删列，即只能删series，不能删行
df['520']=[1314,np.nan]
print(df,df.mean(),df.min(),df.isnull(),sep='\n',end='\n\n\n下面开始是合并\n')

#合并
#基础合并
df1=pd.DataFrame(np.zeros((2,3)),columns=['g','j','l'],index=['c','j'])
df2=pd.DataFrame(np.ones((2,3)),columns=['g','j','l'],index=['c','j'])
print(pd.concat((df1,df2)))#一、行合并
print(pd.concat((df1,df2),axis=1))#二、列合并
left=pd.DataFrame({'key1':['K0','K0','K1','K2'],'key2':['K0','K1','K0','K1'],'A':['A0','A1','A2','A3'],'B':['B0','B1','B2','B3']})
right=pd.DataFrame({'key1':['K0','K1','K1','K2'],'key2':['K0','K0','K0','K0'],'C':['C0','C1','C2','C3'],'D':['D0','D1','D2','D3']})
#有条件的列合并
print(left,right,sep='\n',end='\n')
print(pd.merge(left,right,on=['key1','key2'],how='inner'))#三、内连
print(pd.merge(left,right,on=['key1','key2'],how='outer'))#四、外连
print(pd.merge(left,right,on=['key1','key2'],how='left',indicator=True))#五、左连，并生成一列表示生成方式
print(pd.merge(left,right,on=['key1','key2'],how='right',indicator='indicator_column'),end='\n\n')#六、右连，并生成一列表示生成方式，列名为indicator_column
#有条件的行合并
left = pd.DataFrame({'A':['A0','A1','A2'],'B':['B0','B1','B2']},index=['K0','K1','K2'])
right = pd.DataFrame({'C':['C0','C1','C2'],'D':['D0','D1','D2']},index=['K0','K2','K3'])
print(left,right,sep='\n')
print(pd.merge(left, right, left_index=True, right_index=True, how='outer'))#用index合并
print(pd.merge(left, right, left_index=True, right_index=True, how='inner'))#用index合并
#解决合并时属性名相同的问题
boys = pd.DataFrame({'k': ['K0', 'K1', 'K2'], 'age': [1, 2, 3]})
girls = pd.DataFrame({'k': ['K0', 'K0', 'K3'], 'age': [4, 5, 6]})
print(pd.merge(boys, girls, on='k', suffixes=['_boy', '_girl'], how='inner'))#suffixes解决同名属性问题

#最后说在pandas中使用set_index( )与reset_index( )设置索引

DataFrame.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=False)
keys：列标签或列标签/数组列表，需要设置为索引的列
drop：默认为True，删除用作新索引的列
append：是否将列附加到现有索引，默认为False。
inplace：输入布尔值，表示当前操作是否对原数据生效，默认为False。
verify_integrity：检查新索引的副本。否则，请将检查推迟到必要时进行。将其设置为false将提高该方法的性能，默认为false。

使用方法：Keys设好就行，drop=True就是原则属性列删掉，因为变成Keys了，append=False就是不附加即把原来的Keys（12345……）删掉，只用新设置的Keys即可，inplace=False不对原数据生效的话你就需要用一个新变量来接收这个函数的返回值，如果是True的话则是直接修改原dataframe，最后的参数不用管。


DataFrame.reset_index(level=None, drop=False, inplace=False, col_level=0, col_fill='')
level：数值类型可以为：int、str、tuple或list，默认无，仅从索引中删除给定级别。默认情况下移除所有级别。控制了具体要还原的那个等级的索引 。
drop：当指定drop=False时，则索引列会被还原为普通列；否则，经设置后的新索引值被会丢弃。默认为False。
inplace：输入布尔值，表示当前操作是否对原数据生效，默认为False。
col_level：数值类型为int或str，默认值为0，如果列有多个级别，则确定将标签插入到哪个级别。默认情况下，它将插入到第一级。
col_fill：对象，默认‘’，如果列有多个级别，则确定其他级别的命名方式。如果没有，则重复索引名。

使用方法：只看drop即可，inplace同上，其余三个参数不用管
当对set过的df进行reset，drop=False就是还原成原来的，Keys变回123，set了的Keys变回普通属性，若是drop=True就是key变回123且删掉set了的属性，当对未set过的df进行reset（个人感觉没啥用），keys变回123，还多了一列123属性（其实就相当于前面用123set过一次123），drop=True的话就是增加一列123删掉一列123（就是没有变化)

matplotlib

import matplotlib.pyplot as plt
plt.figure(figsize=(8,6))#生成图像对象，确定大小 
plt.plot([1,2,3,4],[2,4,6,8],linewidth=1.0,color='r')#折线图
plt.scatter([1,2,3,4],[2,4,6,8],linewidth=10.0,color='b')#散点图
plt.bar([1,2,3,4],[2,4,6,8],linewidth=10.0,color='g')#柱状图
plt.legend(['cj','gjl'])#图例
plt.title('love')#标题
plt.xlabel('cj')#X轴标签
plt.ylabel('gjl')#Y轴标签
plt.grid(True)#网格
plt.show()#显示
for i in range(1,5):#补充下子图的使用
    plt.subplot(2,2,i)
    plt.plot([1,2,3],[2,4,6])

npz

#npz
import pandas as pd
import numpy as np
df = pd.DataFrame({'open':[1,3,4],'close':[2,5,6]})
np.savez('./index.npz',df['open'],df['close'])  #numpy用savez即可由numpy存储成npz
D=np.load('./index.npz',allow_pickle=True)      #numpy用load再用'arr_i'读回即可由npz加载成numpy
op,cl=D['arr_0'],D['arr_1']                     #读出每一列
print(type(D),type(op),type(cl))#<class 'numpy.lib.npyio.NpzFile'> <class 'numpy.ndarray'> <class 'numpy.ndarray'>
print(op,cl,end='\n---------------------------------------------\n')
df.to_csv('oc.csv')#注意默认会在最左边新建一列索引

csv

#csv
import tushare as ts 
#ts.set_token('*********************************************')
pro=ts.pro_api()
df=ts.pro_bar(ts_code='600519.SH', start_date='20200101', end_date='20200811')
df.set_index('trade_date',inplace=True)    #主键改成trade_date，代替原先的id列的123…主键
df.to_csv('df.csv')                        #to_csv函数直接存储成csv文件
df=pd.read_csv('df.csv')                   #read_csv又读回来仍然是pandas

#下面是画图：先转np，然后倒转，再转回pd，就可以绘了
cs=np.array(df['close'])
cs=cs[::-1]
df=pd.DataFrame({'close':cs})
df['close'].plot()
import matplotlib.pyplot as plt
plt.show()

re

'''
RE正则表达式必记符号
一：ASCII特殊字符(注意下面几个是单个字符，在ASCII中是只占一个字节的char型)
    \t 制表符，\n 换行符，\r 回车符，\f 换页符，\a 报警符，\e Escape符，\ u十六进制(\与u中间无空格)
二：单个字符
    \d 匹配0~9所有数字，\D匹配非数字
    \w 匹配所有单词字符，即0~9，a~z，A~Z，_，\W匹配所有非单词字符
    \s 匹配所有空白字符，即空格，制表符，回车符，换行符，换页符，\S匹配所有非空白字符
    .  匹配除换行符\n外任意单个字符，re.S 做旗标时可匹配换行符，re.I 做旗标不匹分大小写
    [] 括号内任一字符，[atxz]枚举，[a-f]范围，[^abc]及[^a-f]求否
三：前面式子
    * 前面式子出现0/1/多次
    + 前面式子出现1/多次
    ? 前面式子出现0/1次  
    {m,n} 前面式子至少m次至多n次
四：特别记忆
    () 标记子表达式，里面若有|则表示任先一个，如[]的区别是()后面可以调用前面捕获的串 
    \ 当上面字符只用于表示普通字符时使用，如'\\w'就是两个字符'\w'，'\.'就是单字符'.'
    r 必须加，防止编译器读取时转义，否则请在所有的\前再加一个\
'''
import re
print(re.findall(r'\?\[','?['))  #['?[']
print(re.findall(r'\w','c'))     #['c']
print(re.findall(r'\d\d\d-\d\d\d-\d\d\d\d','123-456-8888'))                 #['123-456-8888']
print(re.search(r'Win(95|98|2000)[\w ]+\1','Win2000 published in 2000').group())#Win2000 published in 2000，\1第一个捕获组所匹配的串
print(re.search(r'<(\w+)>\w+</\1>','<h3>xx</h3>').group())                  #<h3>xx</h3>，注意findall不记录中括号
print(re.search(r'<(?P<tag>\w+)>\w+</(?P=tag)>','<h3>xx</h3>').group())     #<h3>xx</h3>，?P<tag>给组命名，(?P=tag)引用组捕获的串
print(re.search(r'(?<=<h1>).+?(?=</h1>)','cj<h1>loves.com</h1>gjl').group())#loves.com，(?<=<h1>)与(?=</h1>)表示<h1>与</h1>在左/右侧且不作匹配
print(re.findall(r'[a-z0-9_]{3,}@loves\.gjl','sum@loves.gjl',re.I))         #['sum@loves.gjl']，[]{3,}表示[]内字符至少出现3次以上
print(re.findall(r'@.+\.','sun@fkit.com.cn')) #['@fkit.com.']，默认是贪婪模式.+
print(re.findall(r'@.+?\.','sun@fkit.com.cn'))#['@fkit.']，若加了?则是勉强模式.+?

#re的三个函数
#第一个函数：findall输出str组成的list
print(re.findall('\d','12345'))#['1', '2', '3', '4', '5']
#第二个函数：fullmatch完全匹配（实际操作时先判断c非None再取span与group）
c=re.fullmatch('d:\\\\','d:\\')
print(c.span(),c.group(),c)#(0, 3) d:\ <_sre.SRE_Match object; span=(0, 3), match='d:\\'>
#第三个函数：search子母串首次匹配（实际操作时先判断c非None再取span与group）
a=re.search('d:\\\\','ad:\\abc\\n')
b=re.search(r'd:\\','ad:\\abc\\n')#此处体现r的作用，防止编译器取消转义操作，效果同上一行
print(a.span(),a.group(),a)#(1, 4) d:\ <_sre.SRE_Match object; span=(1, 4), match='d:\\'>
print(b.span(),b.group(),b)#(1, 4) d:\ <_sre.SRE_Match object; span=(1, 4), match='d:\\'>

#关于\的测试
print(re.search('\n','\n'))#<_sre.SRE_Match object; span=(0, 1), match='\n'>
print(re.search('\\n','\n'))#<_sre.SRE_Match object; span=(0, 1), match='\n'>
print(re.search('\n','\\n'))#None
print(re.search('\\n','\\n'))#None
print(re.search('\\\\n','\\n'))#<_sre.SRE_Match object; span=(0, 2), match='\\n'>
print(re.search('\\\\n','\\n').group())#\n
#第一句：n是一个字母，\n是换行符，这个\是转义字符，与n结合形成新字符
#第二句：由于没加r，子串'\\n'扔进去时编译器默认取消转义一次变成\n
#第三句：母串'\\n'扔进去时编译器默认不会取消转义，所以仍是\\n
#第四句：同第三句
#第五句：\\n，前面的\取消了后面\n的特殊意义，变成普通的'\n'两个字符，见第五句
#第六句：group输出的话，\\是一个\，n是一个n（证明第五句的两个字符不是\与换行）

json

print('一、分批写入----------')
import json#dumps把字典转换成json格式的str
dic1={'a':'aa','b':'bb','c':'cc'}
dic2={'d':'dd','e':'ee','f':'ff'}
dic3={'g':'gg','h':'hh','i':'ii'}
json_file=open('cj.json','wb+')
json_file.write('[\n'.encode('utf-8'))
text1=json.dumps(dic1)+',\n'
json_file.write(text1.encode('utf-8'))
text2=json.dumps(dic2)+',\n'
json_file.write(text2.encode('utf-8'))
text3=json.dumps(dic3)+',\n'
json_file.write(text3.encode('utf-8'))
json_file.seek(-2,1)
json_file.write('\n]'.encode('utf-8'))
json_file.close()
d=open('cj.json','r')
lst=json.load(d)
print(type(lst),lst)#<class 'list'> [{'a': 'aa', 'b': 'bb', 'c': 'cc'}, {'d': 'dd', 'e': 'ee', 'f': 'ff'}, {'g': 'gg', 'h': 'hh', 'i': 'ii'}]
d.close()

print('二、一次性写入---------')
import json#'dump'把list串写入文件, 'load'把文件读成list串
dic1={'a':'aa','b':'bb','c':'cc'}
dic2={'d':'dd','e':'ee','f':'ff'}
dic3={'g':'gg','h':'hh','i':'ii'}
f=open('GJL.json','w+')
json.dump([dic1,dic2,dic3],f)
f.close()
f=open('GJL.json','r+')
lst=json.load(f)
f.close()
print(type(lst),lst)#<class 'list'> [{'a': 'aa', 'b': 'bb', 'c': 'cc'}, {'d': 'dd', 'e': 'ee', 'f': 'ff'}, {'g': 'gg', 'h': 'hh', 'i': 'ii'}]

print('三、分批写入，不用二进制打开----------')
import json#dumps把字典转换成json格式的str
dic1={'a':'aa','b':'bb','c':'cc'}
dic2={'d':'dd','e':'ee','f':'ff'}
dic3={'g':'gg','h':'hh','i':'ii'}
json_file=open('cj.json','w+')
json_file.write('[\n')
text1=json.dumps(dic1)+',\n'
json_file.write(text1)
text2=json.dumps(dic2)+',\n'
json_file.write(text2)
text3=json.dumps(dic3)#+',\n'#最后一次写入时不写,\n
json_file.write(text3)
#json_file.seek(-2,1)#必须是二进制打开才能前进后退字节
json_file.write('\n]')
json_file.close()
d=open('cj.json','r')
lst=json.load(d)
print(type(lst),lst)#<class 'list'> [{'a': 'aa', 'b': 'bb', 'c': 'cc'}, {'d': 'dd', 'e': 'ee', 'f': 'ff'}, {'g': 'gg', 'h': 'hh', 'i': 'ii'}]
d.close()

txt

# 一、一般读写的编码格式是ANSI
f = open('ANSI_test.txt', 'w+')     # 清空写入
f.write('abc')
f.close()
f = open('ANSI_test.txt', 'a+')     # 追加写入
f.write('def')
f.close()
f = open("ANSI_test.txt", 'r+')     # 读取
print(f.read())                     #abcdef
f.close()

# 二、以二进制形式读写的文件编码格式是utf-8，python中的类型是bytes
f = open('utf-8_test.txt', 'wb+')
f.write('ABC'.encode('utf-8'))      #str类型通过encode转成bytes类型
f.close()
f = open('utf-8_test.txt', 'r+')    #以二进制写入的文内容可直接读出成str类型
print(f.read())                     #ABC
f.close()
f = open('utf-8_test.txt', 'rb+')   #以二进制读出的串是bytes类型
print(f.read())                     #b'ABC'
f.close()
f = open('utf-8_test.txt', 'rb+')   #bytes类型通过decode转成str串
print(f.read().decode('utf-8'))     #ABC
f.close()

# 三、以二进制形式读出的好处：可以feek,tell
f=open('feek_test.txt', 'wb+')
s='''
abc def
ghi jkl
'''
f.write(s.encode('utf-8'))
f.seek(-2,2)#倒数第二个字符即'l'
f.write('x'.encode('utf-8'))
f.close()
f=open('feek_test.txt', 'rb+')
print(f.tell())#0
print(f.read())#b'\nabc def\nghi jkx\n'
print(f.tell())#17
print(f.read(1))#b''
print(f.tell())#17
f.seek(1,0)
print(f.tell())#1
f.read(1)
print(f.tell())#2
f.seek(-1,1)
print(f.tell())#1
f.seek(4,0)
print(f.tell())#4
print(f.read(4))#b' def'
print(f.tell())#8
f.seek(-2,2)
print(f.tell())#15
print(f.read(3))#b'x\n'

time

#time
import time#实际操作用到的就下面三点：
#一、要求两个事件之间的时间差用clock读两次即可
a=time.clock()
b=time.clock()
#二、读回来的str看他的结构然后用strptime转成struct_time类对象（相当于tuple），记好'%Y %m %d %H %M %S'
print(time.strptime('2020年8月24日，23时30分29秒','%Y年%m月%d日，%H时%M分%S秒'))
#time.struct_time(tm_year=2020, tm_mon=8, tm_mday=24, tm_hour=23, tm_min=30, tm_sec=29, tm_wday=0, tm_yday=237, tm_isdst=-1)
#三、由tuple读数值比较直接取成员属性
x=time.localtime()#这个类成员其实就是一个含有以下9个int元素的tuple
print(x.tm_year) #2020 年
print(x.tm_mon)  #8    月
print(x.tm_mday) #24   日
print(x.tm_hour) #21   时
print(x.tm_min)  #53   分
print(x.tm_sec)  #52   秒
print(x.tm_wday) #0    星期一（会自动由年月日求出来）
print(x.tm_yday) #237  今年第237天（会自动由年月日求出来）
print(x.tm_isdst)#-1   没有执行夏令时（中国86年起到92年止）
 
#time（就是三种数据类型在转换，下面详细列出所有函数）
import time
'''直接获取当前时间的float用time.time()'''
a=time.time()                            #当前时间的时间辍形式（float）
print(type(a),a)                         #<class 'float'> 1598274795.736075
'''float转str用time.ctime()'''
b=time.ctime(0)                          #当前时间的字符串形式（str）
print(type(b),b)                         #<class 'str'> Thu Jan  1 08:00:00 1970
'''直接获取当前时间的str用time.ctime()'''
b=time.ctime()#当前时间的字符串形式（str）
print(type(b),b)                         #<class 'str'> Mon Aug 24 21:13:15 2020
'''float转struct_time用time.localtime()'''
f=time.localtime(0)                      #当前地区在1970年1月1日过0秒的时间(struct_time)
print(type(f),f)                         #<class 'time.struct_time'> time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=8, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)
'''直接获取当前时间的struct_time用time.localtime()'''
e=time.localtime()                       #当前地区的时间(struct_time)
print(type(e),e)                         #<class 'time.struct_time'> time.struct_time(tm_year=2020, tm_mon=8, tm_mday=24, tm_hour=21, tm_min=13, tm_sec=15, tm_wday=0, tm_yday=237, tm_isdst=0)
g=time.gmtime()                          #当前0时区的时间(struct_time)
print(type(g),g)                         #<class 'time.struct_time'> time.struct_time(tm_year=2020, tm_mon=8, tm_mday=24, tm_hour=13, tm_min=13, tm_sec=15, tm_wday=0, tm_yday=237, tm_isdst=0)
h=time.gmtime(0)                         #1970年1月1日过0秒的0时区的时间(struct_time)
print(type(h),h)                         #<class 'time.struct_time'> time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)
'''struct_time转float用mktime()'''
k=time.mktime(g)                         #接受时间元组（无默认参数）并返回时间辍（float）
print(type(k),k)                         #<class 'float'> 1598245995.0
'''struct_time转str用strftime()'''
my_format = "%Y/%m/%d %H:%M:%S"
print(time.strftime(my_format, e))       #接收以时间元组，并返回相应格式的字符串（str），2020/08/24 21:13:15
i=time.asctime(h)                        #接受时间元组并返回一个可读的形式为Weekday Month Day HH:MM:SS Year的字符串（str）
print(type(i),i)                         #<class 'str'> Thu Jan  1 00:00:00 1970
j=time.asctime()                         #当前时间的形式为Weekday Month Day HH:MM:SS Year的字符串（str）
print(type(j),j)                         #<class 'str'> Mon Aug 24 21:13:15 2020
'''求进程运行时间用clock()'''
start_time = time.clock()                #以浮点数计算的秒数返回当前进程的 CPU 时间（float）
print(start_time)                        #1288.1695730088904
time.sleep(3)                            #等待三秒，下面的输出比上面的输出多3秒左右，上面的输出是本程序（IDE中是控制台）启动至今的时间
print(time.clock())                      #1291.1694892569685
'''str转float用float'''
sss='14.14'
fff=float(sss)
print(sss,fff)                           #14.14 14.14
'''str转struct_time用strptime(eval不能识别struct_time类)'''
print(time.strptime('2018年3月20日','%Y年%m月%d日'))#time.struct_time(tm_year=2018, tm_mon=3, tm_mday=20, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=79, tm_isdst=-
'''
格式化字符串的含义（让str转tuple用的）：记住数字的七个值：年月日时分秒'%Y %m %d %H %M %S'，文字的值比较少用'%A %a %B %b %I %p'周周月月时午
格式化字符串	日期/时间单元		范围
%Y			年				1900-...
%m			月				12-Jan
%B			月名				January,...
%b			月名缩写			Jan,...
%d			日				31-Jan
%A			星期				Sunday,...
%a			星期缩写			Sun,...
%H			时(24时制)		00-23
%I			时(12时制)		12-Jan
%p			上午/下午		AM,PM
%M			分				00-59
%S			秒				00-59
'''