　　numpy是机器学习里面基础数字算法库，补充了python语言缺乏的数字计算能力，Numpy底层由C语言实现，运行效率充分优化。2006年，Numpy脱离Scipy成为独立的项目。

ndarry数组

numpy.array()　　传入数组参数，可以是一维的也可以是二维三维的，数组会将其转变成ndarray结构。

import numpy as np
a = np.array([1, 2, 3, 4])
# [1 2 3 4]
b = np.array([[1, 2, 3], [1, 2, 3]])    # 创建维度为2的数组
# [[1 2 3]
#  [1 2 3]]
print(type(a))          # <class 'numpy.ndarray'>

ndarray.ndim　　数组的维数

print(a.ndim)   # 1
print(b.ndim)   # 2

ndarray.size　　数组的元素数量

print(b.size)   # 6

len(ndarray)　　查看数组的第一维度数

print(len(b))　　# 2

ndarray.dtype　　　　查看数组元素的类型

print(type(b))      # <class 'numpy.ndarray'>
print(b.dtype)      # int32
b = a.astype("float32")
print(b.dtype)          # float32

ndarray对象属性dtype

类型名	表示符
布尔型	bool
有符号整型	int8(-128~127)/int16/int32/int64
无符号整型	unit(-128~127)/unit16/unit32/unit64
浮点型	float16/float32/float64
复数型	complex64/complex128
字串型	str，每个字符用32位Unicode编码表示

假如有如下numpy数据

data = [('zs', [50,51,52], 15),
        ('ls', [83,71,62], 16),
        ('ww', [90,91,92], 17)]

第一种dtype的设置方式

ary = np.array(data,dtype='U2, 3int32, int32')
print(ary)
# [('zs', [50, 51, 52], 15) 
#  ('ls', [83, 71, 62], 16)
#  ('ww', [90, 91, 92], 17)]
print(ary[0][1])        # [50 51 52]
print(ary[0]['f0'])     # zs

第二种dtype的设置方式

ary = np.array(data, dtype={
    'names':['name', 'scores', 'age'],
    'formats':['U2', '3int32', 'int32']})
print(ary)
# [('zs', [50, 51, 52], 15) 
#  ('ls', [83, 71, 62], 16)
#  ('ww', [90, 91, 92], 17)]
print(ary[0]['age']) # 返回zs的年龄 15
print(ary[2]['scores']) # 返回ww的成绩 [90 91 92]

ndarray数组存放日期数据

dates = ['2011-01-01',
         '2012-01-01',
         '2011-02-01',
         '2012',
         '2011-01-01 10:10:10']
ary = np.array(dates)
print(ary.dtype)    # <U19
ary = ary.astype('M8[D]')
print(ary)
['2011-01-01' 
 '2012-01-01' 
 '2011-02-01' 
 '2012-01-01' 
 '2011-01-01']
print(ary.dtype)        # datetime64[D]
print(ary[1]-ary[0])    # 365 days

类型字符码

类型	字符码
np.bool	?
np.int8/16/32/64	i1/i2/i4/i8
np.unit8/16/32/64	u1/u2/u4/u8
np.float/16/32/64	f2/f4/f8
np.complex64/128	c8/c16
np.str	U<字符数>
np.datetime64	M8[Y] M8[M] M8[D] M8[h] M8[m] M8[s]

字节序前缀，用于多字节整型和字符串：<小端；>大端；[=]硬件字节序

类型字符码格式：<字节序前缀><维度><类型><字节数或字符数>

例如：

3i4：3个元素，整型，每个元素占4个字节

<(2,3)u8：小端字节序，2行3列的二维数组，无符号整型，每个元素占8字节

U7:7个字符的Unicode字符串，每个字符占4个字节，采用默认字节序。

维度操作

视图变维（数据共享）：reshape()和 ravel()

import numpy as np
a = np.arange(1, 9)     # [1 2 3 4 5 6 7 8]
b = a.reshape(2, 4)     # 视图变维    变为2行4列的二维数组
c = b.reshape(2, 2, 2)  # 视图变维    变为2页2行2列的三维数组
d = c.ravel()           # 视图变维   变为1维数组

复制变维（数据独立）：flatten()

print(c.shape)      # (2, 2, 2)
e = c.flatten()     # 压缩成一维数组
print(e.shape)      # (8,)

就地变维：直接改变原数组对象的维度，不返回新数组

import numpy as np
a = np.arange(1, 9)
print(a.shape)      # (8,)
a.shape = (2, 4)
print(a.shape)      # (2, 4)
a.resize(2, 2, 2)
print(a.shape)      # (2, 2, 2)

切片索引

一维切片索引

vector = numpy.array([5, 10, 15, 20])
print(vector[0:3])　　# 切片索引取值# [ 5 10 15]

利用返回值获取元素

import numpy
vector = numpy.array([5, 10, 15, 20])
print(vector == 10)   # [False  True False False]
# 利用返回值获取元素
print(vector[vector == 10])# [10]

二维切片索引

多维的切片是按照各个维度分别取的

import numpy as np 

a = np.arange(25).reshape(5, 5)
print(a)
# [[ 0  1  2  3  4]
#  [ 5  6  7  8  9]
#  [10 11 12 13 14]
#  [15 16 17 18 19]
#  [20 21 22 23 24]]

# 取第1、2行，第2、3、4列
print(a[1:3, 2:5])        # 多维的切片是按照各个维度分别取
print(a[:, 2:5])          # 行取全部，列取第3-5

有时候将一个切片索引的参数改成None，那么ndarray的shape会变

print(a[:, None].shape)            # (5, 1, 5)

None代表新增加一个维度，它有一个别称叫做newaxis，因为在第二维上用了None，所以数组的shape变成了(5, 1, 5)

我们在第三个维度上看看，shape会变成什么样子。

print(a[:, :, None].shape)        # (5, 5, 1)

有时候数组的一个维度上是三个点，它是用省略号代替所有冒号，a[:, :, None]和a[…, None]的输出是一样的，就是因为…代替了前面两个冒号。

print(a[..., None].shape)        # (5, 5, 1)
print(a[:, :, None].shape)        # (5, 5, 1)

数组掩码

import numpy as np

# 输出10以内3的倍数
a = np.arange(1, 10)
mask = a % 3 == 0
print(mask) # [False False  True False False  True False False  True]
print(a[mask])  # [3 6 9]

mask = [2, 2, 6, 6, 4, 4]
print(a)        # [1 2 3 4 5 6 7 8 9]
print(a[mask])  # [3 3 7 7 5 5]

创建数组的常用函数

arange 指定范围和数值间的间隔array，np.arange(起始值，终止值，步长)，取值范围左闭右开。

np.arange(0, 10, 2)
# [0, 2, 4, 6, 8, 10]

reshape 生成0-14的15个数字，使用reshape(3,5)将其构造成一个三行五列的array

arr = np.arange(15).reshape(3, 5)

# array([[0, 1, 2, 3, 4],
#        [5, 6, 7, 8, 9],
#        [10, 11, 12, 13, 14]])

squeeze函数 把shape中为1的维度去掉

arr = arr.reshape(1,1,-1)
print(arr)                # [[[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]]]

print(np.squeeze(arr))    # [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
print(np.squeeze(arr).shape)    # (15,)

zero:生成指定结构的默认为0.的array

a = np.zeros((3,4))

# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]

ones:生成一个三维的array，通过dtype指定类型

a = np.ones((2, 3, 4), dtype=np.int32)  # 3行4列2层

# [[[1 1 1 1]
#   [1 1 1 1]
#   [1 1 1 1]]
# 
#  [[1 1 1 1]
#   [1 1 1 1]
#   [1 1 1 1]]]

numpy.zeros_like()

创造相同结构的全零数组

ary = np.array([1, 2, 3, 4, 5])
print(np.zeros_like(ary))   # [0 0 0 0 0]

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

在指定间隔[start, stop]之间返回均匀num个数字，如果endpoint是True，则不会取最后一个端点stop

np.linspace(2.0, 3.0, num=5)
# array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ])
np.linspace(2.0, 3.0, num=5, endpoint=False)
# array([ 2. ,  2.2,  2.4,  2.6,  2.8])

向下取整np.floor()和向下取整np.ceil()

a = np.random.random((2,2))
# [[0.74892422 0.7665049 ]
#  [0.29296727 0.74230182]]
b = np.floor(10*a)
# [[7. 7.]
#  [2. 7.]]
b = np.ceil(a)
# [[1. 1.]
#  [1. 1.]]

a.T　　转置（行列变换）

a = np.array([[1,2],[3,4]])
print(a.T)# 转置
# [[1 3]
#  [2 4]]

a.resize(1,4)　　变换结构，和reshape相似

a = np.array([[1,2],[3,4]])
a.resize(1,4)
print(a)    # array([[1, 2, 3, 4]])

numpy.clip(a, a_min, a_max, out=None)

把数组a中小于a_min的值都化为a_min，大于a_max的值都化为a_max

import numpy as np

x=np.array([1,2,3,5,6,7,8,9])

print(np.clip(x,3,8))
# [3 3 3 5 6 7 8 8]

pad函数的用法

ndarray = numpy.pad(array, pad_width, mode, **kwargs)

参数：

array为要填补的数组
pad_width是在各维度的各个方向上想要填补的长度，如((1, 1),(2, 2))，表示：在二维数组array第一维(即行)前面填充1行，最后一行填充1行；在二维数组array第二维(即列)前面填充2列，最后面填充2列。
如果直接输入一个整数，则说明各个维度和各个方向所填补的长度都一样。
mode为填补类型，即怎样去填补，有“constant”，“edge”等模式，如果为constant模式，就得指定填补的值，如果不指定，则默认填充0。

对一维数组填充

import numpy as np
array = np.array([1, 1])

# (1,2)表示在一维数组array前面填充1位，最后面填充2位
#  constant_values=(0,2) 表示前面填充0，后面填充2
ndarray=np.pad(array,(1,2),'constant', constant_values=(0,2)) 

print(array)        # [1 1]
print(ndarray)        # [0 1 1 2 2]

对二维数组填充

import numpy as np
array = np.array([[1, 1],[2,2]])
"""
((1,1),(2,2))
在二维数组array第一维（此处便是行）前面填充1行，最后面填充1行；
在二维数组array第二维（此处便是列）前面填充2列，最后面填充2列
constant_values=(0,3) 表示第一维填充0，第二维填充3
"""
ndarray=np.pad(array,((1,1),(2,2)),'constant', constant_values=(0,3)) 

print(array)
# [[1 1]
#  [2 2]]

print(ndarray)
# [[0 0 0 0 3 3]
#  [0 0 1 1 3 3]
#  [0 0 2 2 3 3]
#  [0 0 3 3 3 3]]

数组的组合与拆分

np.hstack(a,b)　　横向拼接

import numpy as np
a = np.arange(1, 7).reshape(2, 3)
b = np.arange(7, 13).reshape(2, 3)
# 水平方向完成组合操作，生成新数组
c = np.hstack((a, b))       # (2, 6)

np.vstack(a,b)　　纵向拼接

import numpy as np
a = np.arange(1, 7).reshape(2, 3)
b = np.arange(7, 13).reshape(2, 3)
# 垂直方向完成组合操作，生成新数组
c = np.vstack((a, b))       # (4, 3)

np.hsplit(a,2)　　矩阵横向切割　　把a横竖切成2分

# a.shape (2, 6)
# 水平方向完成拆分操作，生成两个数组
d, e = np.hsplit(c, 2)
# d.shape      (2, 3)
# e.shape      (2, 3)

np.vsplit(a,2)　　矩阵纵向切割　把a纵横切2分

# a.shape (4,3)
# 垂直方向完成拆分操作，生成两个数组
d, e = np.vsplit(a, 2)
# d.shape   (2, 3)
# e.shape   (2, 3)

深度方向（3维）

import numpy as np
a = np.arange(1, 7).reshape(2, 3)
b = np.arange(7, 13).reshape(2, 3)
# 深度方向（3维）完成组合操作，生成新数组
i = np.dstack((a, b))   # (2, 3, 2)
print(i.shape)
# 深度方向（3维）完成拆分操作，生成两个数组
k, l = np.dsplit(i, 2)
# k.shape  # (2, 3, 1)
# l.shape  # (2, 3, 1)

通过axis方法进行数组拼接

axis的取值

0: 第一个维度方向，垂直方向
1: 第二个维度方向，水平方向
2: 第三个维度方向

numpy.concatenate((a1, a2, ...), axis=0)

import numpy as np

a = np.array([[1, 2], [3, 4]])      # (2, 2)
b = np.array([[5, 6]])              # (1, 2)

c=np.concatenate((a, b), axis=0)        # (3, 2)
d=np.concatenate((a, b.T), axis=1)        # (2, 3)

拆分，axis的取值同上
np.split(c, 2, axis=0)

注意：拼接的数组，除了需要拼接的维度可以不同，其他维度必须相同。

例如，a.shape为(4,5,6,10)，b.shape为(4,5,6,20)

np.concatenate([a,b], axis=3) # 返回张量的shape为(4,5,6,30)

矩阵运算

column是列，row是行。

相加、相减、开根号、e平方、取log对数

a = np.array([10,20,30,40])
b = np.array(4)

print(np.abs(-b))    # 取绝对值
print(a - b)    # array([ 6, 16, 26, 36])

# 取平方
print(a**2) # array([ 100,  400,  900, 1600])
print(np.square(a))

# 开根号
print(np.sqrt(a**2))   # [10. 20. 30. 40.]

# 以e为底的对数
print(np.exp(a))    # [2.20264658e+04 4.85165195e+08 1.06864746e+13 2.35385267e+17]

# 以e为底的对数
print(np.log(a))    # [2.30258509 2.99573227 3.40119738 3.68887945]
# 以10为底的对数
print(np.log10(a))  # [1.         1.30103    1.47712125 1.60205999]

求和

matrix = numpy.array([[1,2,3],
                      [4,5,6],
                     [7,8,9]])
print(matrix.sum())# 45
print(matrix.sum(1))# 按每行求和 # [ 6 15 24]
print(matrix.sum(0))# 按每列求和 # [12 15 18]

sum(1) 是 sum(axis=1)) 的缩写，1表示按照 x轴方向求和，0表示按照y轴方向求和

矩阵乘法

A*B　　A.dot(B)　　np.dot(A,B)

import numpy as np
A = np.array([[1, 1], [0, 1]])
B = np.array([[2, 0], [3, 4]])
print(A*B)

print(A.dot(B))    # A*B
print(np.dot(A,B))  # A*B
# [[2 0]
#  [0 4]]

矩阵求均值　　

numpy.mean(a, axis, dtype, out，keepdims )

mean()函数功能：求取均值
经常操作的参数为axis，以m * n矩阵举例：

axis 不设置值，对 m*n 个数求均值，返回一个实数
axis = 0：压缩行，垂直方向，对各列求均值，返回 1* n 矩阵
axis =1 ：压缩列，水平方向，对各行求均值，返回 m *1 矩阵

a = np.array([[1, 2], [3, 4]])
print(a)
# array([[1, 2],
#        [3, 4]])
print(np.mean(a))   # 2.5
print(np.mean(a, axis=0))  # axis=0，计算每一列的均值
# array([ 2.,  3.])
print(np.mean(a, axis=1))  # 计算每一行的均值 
# array([ 1.5,  3.5])

numpy的函数有两种用法，以mean为例，第一a=np.mean(array);第二a=array.mean()

np.max() np.min() np.ptp()： 返回一个数组中最大值/最小值/极差

np.argmax() np.argmin()： 返回一个数组中最大/最小元素的下标

np.maximum() np.minimum()： 将两个同维数组中对应元素中最大/最小元素构成一个新的数组

np.median(array)　　中位数，如果为偶数，返回中间两个元素的平均值。

np.std(array) 　　标准差

复制的区别

地址复制：通过 b = a 复制 a 的值，b 与 a 指向同一地址，改变 b 同时也改变 a。

 1 a = np.arange(12)
 2 b = a
 3 print(a is b)
 4  
 5 print(a.shape)
 6 print(b.shape)
 7 b.shape = (3,4)
 8 print(a.shape)
 9 print(b.shape)
10  
11 # True
12 # (12,)
13 # (12,)
14 # (3, 4)
15 # (3, 4)

View Code

复制值：通过 a.view() 仅复制值，当对 c 值进行改变会改变 a 的对应的值，而改变 c 的 shape 不改变 a 的 shape，只有值会变，矩阵结构不变

 1 a = np.arange(12)# [ 0  1  2  3  4  5  6  7  8  9 10 11]
 2 c = a.view()
 3 print(c is a)
 4 
 5 c.shape = (2,6)
 6 c[0,0] = 9999
 7  
 8 print(a)
 9 print(c)
10  
11 # False
12 # [9999    1    2    3    4    5    6    7    8    9   10   11]
13 # [[9999    1    2    3    4    5]
14 # [   6    7    8    9   10   11]]

View Code

完全拷贝：a.copy() 进行的完整的拷贝，产生一份完全相同的独立的复制

 1 a = np.arange(12)
 2 c = a.copy()
 3 print(c is a)
 4  
 5 c.shape = 2,6
 6 c[0,0] = 9999
 7  
 8 print(a)
 9 print(c)
10  
11 # False
12 # [ 0  1  2  3  4  5  6  7  8  9 10 11]
13 # [[9999    1    2    3    4    5]
14 # [   6    7    8    9   10   11]]

View Code

numpy.random 随机模块

numpy的random模块用于生成随机数，

numpy.random.random(D0, d1,....dN)　　

生成[0, 1)之间指定结构的随机数

np.random.random((2, 3))

# [[ 0.86166627,  0.37756207,  0.94265883],
#  [ 0.9768257 ,  0.96915312,  0.33495431]]

numpy.random.rand(D0, d1, ..., DN)：

给定形状的数组，并在[0,1)之间

np.random.rand(3,2)
# array([[ 0.14022471,  0.96360618],  #random
#        [ 0.37601032,  0.25528411],  #random
#        [ 0.49313049,  0.94909878]]) #random

numpy.random.randn(D0, d1, ..., DN)：

从“标准正态分布”返回一个或多个样本

a = np.random.randn(2, 4)
# [[-0.9115162  -1.32887292 -1.02910152  0.8023337 ]
#  [-1.14456771 -0.53251834 -1.75465906 -1.25668335]]

numpy.random.normal（loc = 0.0，scale = 1.0，size = None）

从正态分布中中抽取随机样本，其中均值为loc，方差为scale，size是形状

s = np.random.normal(0,1, 1000)
print(s.shape)  # (1000,)

numpy.random.randint(low, high=None, size=None, dtype='l')：

生成[low,high)的随机整数，取数范围：若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数。

a = np.random.randint(5, size=(2, 4))
# array([[4, 0, 2, 1],
#        [3, 2, 2, 0]])

b = np.random.randint(5,10,size=(2, 4))
# [[6 9 8 5]
#  [8 8 6 8]]

numpy.random.uniform(low=0.0, high=1.0, size=None)

功能：从一个均匀分布[low,high)中随机采样，注意定义域是左闭右开，即包含low，不包含high.

参数：

low: 采样下界，float类型，默认值为0；
high: 采样上界，float类型，默认值为1；
size: 输出样本数目，为int或元组(tuple)类型，例如，size=(m,n,k), 则输出m*n*k个样本，缺省时输出1个值。

numpy.random.choice(a, size=None, replace=True, p=None)

从序列中获取元素，若a为整数，元素取值为np.range(a)中随机数；若a为数组，取值为a数组元素中随机元素。

size：表示从a中随机选取size个数
replace：抽样之后是否放回，False不放回抽样，True放回抽样。
p：表示每个元素被抽取的概率，如果没有指定，a中所有元素被选取的概率是相等的。

numpy.random.shuffle(x)：

对X进行重排序，如果X为多维数组，只沿第一条轴洗牌(横轴)，输出为None。

arr = np.arange(9).reshape((3, 3))
# [[0 1 2]
#  [3 4 5]
#  [6 7 8]]
np.random.shuffle(arr)
# [[3 4 5]
#  [0 1 2]
#  [6 7 8]]

numpy.random.seed(seed=None)　　　　# 种下随机种子，使得生成的随机数相同

读取文件

numpy.gerfromtxt()用于读取文件，其中传入的参数依次是：

　　1、需要读取txt文件位置，此处文件与程序位于同一目录下

　　2、delimiter 分割的标记

　　3、dtype 转换类型，如果文件中既有文本类型也有数字类型，就先转成文本类型

import numpy
 
world_alcohol = numpy.genfromtxt("world_alcohol.txt", delimiter=",",dtype=str)
print(type(world_alcohol))
print(world_alcohol)
print(help(numpy.genfromtxt))

help(numpy.genformtxt)用于查看帮助文档

np.loadtxt("path", delimiter=",", usecols=(1, 3), unpack=False, dtype='u10, f8', converters={1:func})

参数：

"path"：读取csv文件路径
'../aapl.csv'：文件路径
delimiter=','：分隔符
usecols=(1, 3)：读取1、3两列（下标从0开始）
unpack=False：是否按列拆包
dtype='U10, f8'：制定返回每一列数组中元素的类型
converters={1:func} ：转换器函数字典

import numpy as np
import datetime as dt
# 日期转换函数
def dmy2ymd(dmy):
    # 把“日月年”字符串转换成“年月日”字符串
    dmy = str(dmy, encoding='utf-8')
    time = dt.datetime.strptime(dmy, '%d-%m-%Y').date()
    t = time.strftime('%Y-%m-%d')
    return t
dates, opening_prices,highest_prices, lowest_prices, closeing_prices  = np.loadtxt(
    './aapl.csv',     # 文件路径
    delimiter=',',          # 分隔符
    usecols=(1, 3, 4, 5, 6),            # 读取1、3、4、5、6两列 （下标从0开始）
    unpack=True,
    dtype='M8[D], f8, f8, f8, f8',      # 制定返回每一列数组中元素的类型
    converters={1:dmy2ymd})

print(dates)
# 表格中数据 28-01-2011
# 转换后数据 2011-01-28

如果不设置dtype，t=time.strtime()换成t=time.weekday()得到的结果是[4. 0. 1. 2. 3. 4. 0. 1.]

卷积

a = [1 2 3 4 5] 原数组
b = [8 7 6] 　　卷积核数组 kernel

使用b作为卷积核对a数组做一维卷积运算的过程如下：

44 65 86         有效卷积 (valid)
         23 44 65 86 59      同维卷积 (same)
      8  23 44 65 86 59 30   完全卷积 (full)
0  0  1  2  3  4  5  0  0
6  7  8
   6  7  8
      6  7  8
         6  7  8
            6  7  8
               6  7  8
                  6  7  8

c = np.convolve(a, b, '卷积类型')

使用卷积函数numpy.convolve(a, b, 卷积类型)实现5日均线

sma52 = np.convolve( closing_prices, np.ones(5) / 5, 'valid')
mp.plot(dates[4:], sma52, c='limegreen', alpha=0.5, linewidth=6, label='SMA-5(2)')

加权卷积

使用卷积函数numpy.convolve(a, b, 卷积类型)实现加权5日均线

# 实现加权卷积
# 通过指数函数，寻求一组卷积核 
kernel = np.exp(np.linspace(-1, 0, 5))
kernel = kernel[::-1]
kernel /= kernel.sum()
print(kernel)
sma53 = np.convolve(closing_prices, kernel, 'valid')
mp.plot(dates[4:], sma53, label='SMA-5(3)', linewidth=1, color='violet', linestyle='-')

时间数据处理

import numpy as np
import datetime as dt

# 转换器函数：将日-月-年格式的日期字符串转换为星期
def dmy2wdays(dmy):
    dmy = str(dmy, encoding='utf-8')
    d = dt.datetime.strptime(dmy, '%d-%m-%Y').date()
    wday = d.weekday()
    return wday


# 加载文件，第一列 wdays时间数据
wdays, closing_prices = np.loadtxt('./aapl.csv', delimiter=',', usecols=(1), unpack=True, converters={1: dmy2wdays})
print(wdays)
# [4. 0. 1. 2. 3. 4. 0. 1. 2. 3. 4. 0. 1. 2. 3. 4. 1. 2. 3. 4. 0. 1. 2. 3. 4. 0. 1. 2. 3. 4.]

日月年转年月日

def dmy2ymd(dmy):
    # 把日月年字符串转为年月日字符串
    print(dmy)      # b'11-03-2011'
    dmy = str(dmy, encoding='utf-8')
    d = dt.datetime.strptime(dmy, '%d-%m-%Y').date()
    ymd = d.strftime('%Y-%m-%d')
    print(ymd)      # 2011-03-11
    return ymd

参考文献

原文出处：https://www.cnblogs.com/LXP-Never/p/9638794.html

来源：oschina

链接：https://my.oschina.net/u/4357035/blog/3271145

标签

Apache Axis