穹灵科技

Numpy的学习笔记

#numpy
自用内容

简写np，矩阵的运算，
下面是输出矩阵：

import numpy as np
array = np.array([[1,2,3],[2,3,4]])
print(array)
#维度
print(“number of dim: “,array.ndim)
#形状 ？X ？的数组
print(“shape:”,array.shape)
#多少元素
print(“size:”,array.size)

[[1 2 3]
[2 3 4]]
number of dim: 2
shape: (2, 3)
size: 6

创建array，定义type
a = np.array([2,23,4],dtype = np.int64)
1
生成全部为0 和1的数组三行四列

zeroArray = np.zeros((3,4))
print(zeroArray)
oneArray = np.ones((3,4))
print(oneArray)

[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]

1.生成有步长的数组：
2.生成0—11的数列

arangeArray = np.arange(10,20,2)
print(arangeArray)
numArray = np.arange(12).reshape((3,4))
print(numArray)

[10 12 14 16 18]
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]

生成线段，生成5点4段数列

linArray = np.linspace(1,10,6).reshape((2,3))
print(linArray)

[[ 1. 2.8 4.6]
[ 6.4 8.2 10. ]]

numpy基础运算
1.加减法
2.平方
3.三角函数的运算

aArray = np.array([10,20,30,40])
bArray = np.arange(4)
c= aArray – bArray
print(c)
d = c **2
print(d)
sinA = np.sin(10)
print(sinA)

[10 19 28 37]
[ 100 361 784 1369]
-0.5440211108893698

数组的逻辑运算
1.筛选出数组中比3小的数
2.等于3的数
3.数组中逐个相乘

print(bArray<3)
print(bArray == 3)
aShape = aArray.reshape(2,2)
bShape = bArray.reshape(2,2)
print(aShape)
print(bShape)
mutArray = aShape * bShape #逐个相乘
mut_dotArray = np.dot(aShape,bShape) #矩阵相乘
#或者
mut_Array = aShape.dot(bShape)

print(mutArray)
print(mut_dotArray)

[ True True True False]
[False False False True]
[[10 20]
[30 40]]
[[0 1]
[2 3]]
[[ 0 20]
[ 60 120]]
[[ 40 70]
[ 80 150]]

随机生成一个0-1的矩阵
求和np.sum()
*小值np.min()
*大值np.max()
axis = 1 行
axis = 0 列

randomArray = np.random.random((2,4))
print(randomArray)
print(np.sum(randomArray,axis = 1))

[[0.54661074 0.27343044 0.42980382 0.04123646]
[0.10769581 0.77549246 0.28787614 0.27292254]]

#*小值的索引
print(np.argmin(randomArray))
#max index
print(np.argmax(randomArray))
#mean
print(np.mean(randomArray))
print(randomArray.mean())
#median
print(np.median(randomArray))
#累加
print(np.cumsum(randomArray))
#累差
print(np.diff(randomArray))
#排序sort,逐行排序
print(np.sort(randomArray))
#矩阵反向：行列对换,转置
print(np.transpose(randomArray))
print(randomArray.T)

3
5
0.34188355032710077
0.34188355032710077
0.2806532854593555
[0.54661074 0.82004118 1.249845 1.29108145 1.39877726 2.17426972
2.46214586 2.7350684 ]
[[-0.27318031 0.15637338 -0.38856736]
[ 0.66779665 -0.48761633 -0.01495359]]
[[0.04123646 0.27343044 0.42980382 0.54661074]
[0.10769581 0.27292254 0.28787614 0.77549246]]
[[0.54661074 0.10769581]
[0.27343044 0.77549246]
[0.42980382 0.28787614]
[0.04123646 0.27292254]]
[[0.54661074 0.10769581]
[0.27343044 0.77549246]
[0.42980382 0.28787614]
[0.04123646 0.27292254]]

clip
让小于或大于设定的某个数，都近似于设定的数字

setA = np.arange(2,14).reshape(3,4)
print(setA)
#求列中的平均值
print(np.mean(setA,axis = 0))
print(np.clip(setA,5,9))

[[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]]
[6. 7. 8. 9.]
[[5 5 5 5]
[6 7 8 9]
[9 9 9 9]]

index
print(setA)
#第3行的所有数
print(setA[2])
print(setA[2,:])
#第2行第三列
print(setA[1,2])
print(setA[2][1])
#第2列：
print(setA[:,1])
#取【7，8】,取左不取右
print(setA[1,1:3])

[[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]]
[10 11 12 13]
[10 11 12 13]

[ 3 7 11]
[7 8]

for循环输出每行，row和column都只是参数名

for row in setA:
print(row)

[2 3 4 5]
[6 7 8 9]
[10 11 12 13]

for循环输出每列

for column in setA.T:
print(column)

[ 2 6 10]
[ 3 7 11]
[ 4 8 12]
[ 5 9 13]

迭代出每一个数

for item in setA.flat:
print(item)

#第二行的每一个数

print(setA)

for itemR2 in setA[1].flat:
print(itemR2)

[[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]]

array的数据处理
setD = np.array([1,1,1])
setC = np.array([2,2,2])
setE = np.array([3,3])
print(np.vstack((setD,setC)))#vertical stack 变成二维上下合并
print(np.hstack((setD,setC)))#左右合并

[[1 1 1]
[2 2 2]]
[1 1 1 2 2 2]

一维数组变二维数组
#将一维数组增加了一个维度，变成二维数组（1X3）
print(setD[np.newaxis,:])
#变成（3×1）
print(setD[:,np.newaxis])

[[1 1 1]]
[[1]
[1]
[1]]

多个array的合并，任意维度
#左右合并 axis = 1
setRow = np.concatenate((setC[np.newaxis,:],setD[np.newaxis,:]),axis = 1)
print(setRow)
#上下合并 axis = 0
setColumn = np.concatenate((setC[np.newaxis,:],setD[np.newaxis,:]),axis = 0)
print(setColumn)

[[2 2 2 1 1 1]]
[[2 2 2]
[1 1 1]]

array的分割：
myArr = np.arange(12).reshape(3,4)
print(myArr)
#左右分割
print(np.split(myArr,2,axis = 1))
print(np.hsplit(myArr,2))
#左右不等量分割,分出三个不等量的矩阵
print(np.array_split(myArr,3,axis = 1))
#上下分割
print(np.vsplit(myArr,3))

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

Numpy 的copy 和deep copy
在numpyArray中，改变了赋值的数，被赋值的数也会跟着改变

#copy,仅copy初始值，不copy后面可能会改变的
print(setC)

setCopy = setC.copy()
#1.更改数组中的某一个值,得是整数
setC[0] = 3
print(setC)
#2.同时改变几个数字：
setC[1:3] = [4,6]
print(setC)
print(setCopy)

[2 2 2]
[3 2 2]
[3 4 6]
[2 2 2]
1
2
3
4

 

大数据时代我们几乎每个人都得了解一下虚拟机与大数据平台。趋势如此，要不什么也很难前行。的确如此，从网格运算思想的出现，再到了后来virtual-box、VMware、kvm、virtual PC等等方案。到了前两年，也许是因为是亚马逊公司太过尊大，虚拟机的集成方案cloudstack、openstack、zstack应运而生。在技术层面本并不是一种太过神秘的技术，只是有了资本的介入，这虚拟机之上的计算技术竟然炒到“虚拟机成就了信息技术的革命新时代”！

云计算有很多种，我说说我理解的目前比较经典应用：服务端云化，应用端云化。

服务端云化

传统的应用服务器要找机房，买主机，买存储，买带宽等硬件设备，然后再聘请专业员工维护，这些都需要提前投资一笔钱。然后买来的机器都是固定性能的，在一些存在峰值计算的情况下就会出现资源不足的情况。 那么云计算服务(服务端云化)就是有一个土豪公司购买100倍你需要的资源，然后安装好物理设备，在上面搭建云平台，然后再将这些物理资源标注成服务器常用资源然后售卖。只要足够多客户使用就能收回投资。 例如我要搭建一个论坛，我找到了一个discuss版本，传统我要去买机器，买带宽，注册备案等。这些买来的设备我要投入一笔钱，不用的话只能卖二手，价格也不好。那么这时如果我选择阿里云，选择2个CPU，4G内存，100G存储，那么每月付30人民币，一年也就360元。如果自己买这些估计要一次投入6~7万。而且还需要请员工维护。对于创业者这笔钱还是很重要的。 还有很重要的是我购买的云资源不是固定的，可以根据需要申请或者减少资源，这样只需付出临时需要资源的钱就行了。就像平常出行只有2个人，滴滴打车打的是普通轿车或者拼车，但是像促销活动时需要拉6位乘客，于是我可以选择6座商务车，如果像双十一人多我可以选择面公交车。这样我只需要付出专车的钱就能使用不同款的专车服务。云计算也是这个道理，但服务器需要多少资源(根据人数叫车)，就申请多少，不用自己买服务器(自己买车)。 服务端云化，就是将CPU，内存，存储，网络等都资源话，由一个土豪公司统一维护，提供计算资源，就像提供水电一样。服务端云化主要针对是服务提供者。个人用户没有影响。

应用端云化

应用端比较经典是网盘和office云化。 网盘，例如百度网盘，提供网络存储，目前的宽带和4G能提供足够带宽，这样就能实现多设备访问相同资料。 office云化，以前office都需要安装office2010之类的软件才能使用，那么现在office365提供使用浏览器就能打开和编辑Word文档并且将文件存储在onedriver，这样就实现了云端存储了。 office云化后，可以实现协同办公，例如TIM的协同办公，或者“一起写”都能多人同时编辑，这些编辑变化都是在云端处理的。 客户端云化是对普通用户影响*大的，这将是未来平板可以替代笔记本电脑的一个重要技术实现。

至于云计算*大的用处就是云计算出现以前，很多企业对安全问题的处理多停留在买个防火墙、WAF、入侵防御、漏洞修复之上。随着云计算的发展和IT时代到来，网络安全问题愈发凸显，已经成为关乎企业信息安全与有序经营的重要环节。针对DDoS攻击，使用云平台的高防服务是省钱省力的一件事情。DDoS攻击不会是每天都发生的事情，如果自己组建个团队再部署一个清洗机房，拉好几百G的带宽来做这件事情成本高精力花的多，得不偿失。*近PS Cloud与SaaS应用，可支持工业互联网，涵盖协同研发、产业链协同、智能制造、财务共享、人力资源管理、数字营销等多种应用场景，为中小企业提供一站式解决方案。云计算给企业带来了便捷。

python3 加密模块的实现（hashlib，hmac）

hashlib模块：
Version：Python 3.6.1
hashlib:不可逆加密
hmac：不可逆键值对方式加密

hashlib模块：
hashlib模块为不同的安全哈希/安全散列（Secure Hash Algorithm）和 信息摘要算法（Message Digest Algorithm）实现了一个公共的、通用的接口，也可以说是一个统一的入口。因为hashlib模块不仅仅是整合了md5和sha模块的功能，还提供了对更多中算法的函数实现，如：MD5，SHA1，SHA224，SHA256，SHA384和SHA512。
使用步骤：
1、获取一个哈希算法对应的哈希对象：
（1）：通过hashlib.new(哈希算法名称,初始出入信息)来获取这个哈希对象，如：hashlib.new(“MD5”,“username”)，hashlib.new(“SHA1”,“username”)等。
（2）：通过hashlib.哈希算法名称()来获取这个哈希对象，如：hashlib.md5()，hashlib.sha1()等。
2、设置追加信息：
调用哈希对象的updata(输入的信息)方法，设置追加信息。多次调用后等价于把所有追加的参数全部拼接起来作为一个参数，传递给update()，是累加，不是覆盖。
3、获取输入信息对应的摘要：
调用已经的到哈希对象的digest()或者hexdigest()，可得到传递给update()方法的字符串参数的摘要信息。
（1）digest()与hexdigest()的区别：
a、digest()：摘要信息是一个二进制格式的字符串，其中可能包含非ASCII字符，包括NUL字节，该字符串长度可以通过哈希对象的digest_size属性获取。
b、hexdigest()：摘要信息是一个16进制格式的字符串，该字符串中只包含16进制的数字，且长度是digest()返回结果长度的2倍。
示例代码1：

def hash_test():
m = hashlib.md5()
m.update(b”username”)
m.update(b”password”) #*终加密的字符串参数是：username + password
print(m.digest_size)
print(m.digest())
print(m.hexdigest())
hash_test()

返回结果：

16
b’\xd5\x1c\x9a~\x93Stj` \xf9`-E))’
d51c9a7e9353746a6020f9602d452929

代码示例2：

def hash_func():
# hashlib.new(name[, data]) 创建hashlib(非首选), name=算法名, data:数据
hash = hashlib.new(‘sha1’, ‘username’.encode())
strs = hash.name # hash名称, 可传给new()使用
hash.update(“password”.encode()) # 字节缓冲区 hash.update(x) hash.update(y) == hash.update(x+y)
hash = hash.copy() # 拷贝hash对象副本
print(strs, hash)

# algorithms_guaranteed返回的是所有平台支持的hash算法的名称，结果是一个集合
dics = hashlib.algorithms_guaranteed
print(dics)

# algorithms_available返回的是在Python解析器中可用的hash算法的名称, 传递给new()时, 可识别，结果也是一个集合
dics1 = hashlib.algorithms_available
print(dics1)

“””
加盐加密方法介绍：
hashlib.pbkdf2_hmac(hash_name, password, salt, iterations, dklen=None)
hash_name:hash名称, password:数据, salt:盐, iterations:循环次数, dklen:密钥长度
“””
hash_bytes = hashlib.pbkdf2_hmac(‘SHA1′, b’password’, b’80’, 100, 64)
print(hash_bytes)

num = hash.digest_size # hash结果的大小
num1 = hash.block_size # hash算法的内部块的大小
print(num, num1)

hash_func()

返回结果：

sha1
<sha1 HASH object @ 0x000002741602E030>
{‘sha256’, ‘blake2s’, ‘sha224’, ‘sha3_512’, ‘shake_128’, ‘md5’, ‘sha384’, ‘blake2b’, ‘sha3_256’, ‘sha512’, ‘sha3_224’, ‘shake_256’, ‘sha1’, ‘sha3_384’}
{‘sha256’, ‘blake2b’, ‘sha3_256’, ‘whirlpool’, ‘SHA’, ‘md5’, ‘sha384’, ‘RIPEMD160’, ‘dsaEncryption’, ‘sha’, ‘sha1’, ‘md4’, ‘SHA1’, ‘MD4’, ‘sha224’, ‘DSA-SHA’, ‘SHA256’, ‘sha512’, ‘sha3_224’, ‘SHA384’, ‘SHA224’, ‘SHA512’, ‘ripemd160’, ‘MD5’, ‘dsaWithSHA’, ‘blake2s’, ‘sha3_512’, ‘shake_128’, ‘DSA’, ‘shake_256’, ‘ecdsa-with-SHA1’, ‘sha3_384′}
b’]\x85C\xff\x1d\xe8\xce\x97\x128\x9bP\xe6\x98\xdf/\x1eQ\x19\xb4\x04v\xf5\xcd\x00\xb8\xff#\xee\xa7\x07\x81)\xb8\xc7Se\x85\xef\xfa\x9d\x0e\x9auA8\x19\t\x0e\xee\xb5`\x9b\x07:2M\xd4\xc0\x0c\xfaz^/’
20
64

hmac模块
hmac算法也是一种一种单项加密算法，并且它是基于上面各种哈希算法/散列算法的，只是它可以在运算过程中使用一个密钥来增增强安全性。hmac模块实现了HAMC算法，提供了相应的函数和方法，且与hashlib提供的api基本一致。
使用步骤：
hmac模块的使用步骤与hashlib模块基本一致，只是在获取hmac对象时，只能使用hmac.new()函数，因为hmac模块没有提供与具体哈希算法对应的函数来获取hmac对象。如：hashlib可以用hashlib.md5()来产生一个哈希对象，但是hmac不行。

代码示例1：

def hmac_demo():
hash = hmac.new(b”pwd”)
hash.update(b”uname”)
h_str = hash.hexdigest()
print(h_str.upper())
boolean = hmac.compare_digest(h_str, hmac.new(“pwd”.encode(), “uname”.encode()).hexdigest())
print(boolean)
hmac_demo()

返回结果：

675440AD536E602C322C90F8E0051975
True

示例代码2：

def hmac_func():
# 创建key和内容,再进行加密
# hmac.new(key, msg=None, digestmod=None)
# 创建新的hmac对象, key:键, msg:update(msg), digestmod:hash名称(同hashlib.new())(默认md5)
hc = hmac.new(“userid”.encode())
hc.update(“username”.encode()) # 字节缓冲区 hc.update(a) hc.update(b) == hc.update(a+b)
hash_bytes = hc.digest() # 字节hash
print(hash_bytes)
hash_str = hc.hexdigest().upper() # 16进制hash字符串
print(hash_str)
hc = hc.copy() # 拷贝hmac副本
print(hc)
num = hc.digest_size # hash大小
print(num)
strs = hc.name # hash名称
print(strs)
# hmac.compare_digest(a, b) // 比较两个hash密钥是否相同, 参数可为: str / bytes-like object, (注:建议使用此方法,不建议使用a==b)
boolean = hmac.compare_digest(hmac.new(“uid”.encode(), “uname”.encode()).digest(), hmac.new(“uid”.encode(), “uname”.encode()).digest())
print(boolean)

hmac_func()

返回结果：

b’\x82jU\xd4I\xa3A?\x1d\x05\x00\xd89\xf9z\xb1′
826A55D449A3413F1D0500D839F97AB1
<hmac.HMAC object at 0x0000014F15668080>
16
hmac-md5
True

云计算是一种通过互联网提供与计算相关资源的可扩展的方法。工程学科应用于这个概念则被称为云计算工程，它与任何与云计算相关的技术相关联。

云计算构建了一个系统化的方法，专注于云计算应用程序的标准化和治理。

基础设施即服务
平台即服务
软件即服务
云计算工程师是负责与云计算相关的任何技术问题的IT专业人员。他们的职责包括支持、维护、设计、管理、计划。

云计算安全工程师
云计算系统工程师
云计算架构师
云计算网络工程师
云计算软件工程师
要想成为一名云计算工程师，IT专业人员首先应该掌握云计算主要领域的技能。

首先从掌握基本概念开始，然后通过掌握完全面向云计算的特定供应商的平台或技术等重要领域来增强其专业知识水平，因为这有助于为IT专业人员增加附加优势。但要获得这些特定领域的知识，IT专业人员应具备软件、操作和架构角色所需的技能。

通常在操作角色中获得的技能要了解恢复灾难，故障转移和冗余的方法。只要对这些概念有良好的把握，就可以通过一些培训轻松学习云计算架构师概念。

而了解应用程序网络、虚拟化和存储技术的操作和设计，将为IT专业人员在云计算领域增加额外的优势。

IT人员*好具有强大的编程背景，而如果熟练操作OpenStack，AWS(Amazon Web Service)和Azure则更好。

掌握这些技术中的至少一种，将有助于对他人设计的软件的理解。总之，这都要求IT人员具有更加丰富的经验和实践技能。

云计算架构的基础是基于API和Web服务。在这些服务模式方面具有良好的专业知识水平将使IT人员在掌握云基础知识方面*一步。

“云计算工程师” 这个概念在IT时代是一个进化的角色，IT专业人员在云计算时代取得成功的同时，还需要一系列高级技能。

这些技能通过云计算认证培训所获得，行业标准认证为IT人员提供了获得云计算工程师工作的边缘优势。

AWS
Azure
MCSE-基础架构和云平台
CCNA和CCNP云计算版本
VMware VCP7-CMA
AWS的认证

它包括学历证书和专业证书。AWS认证涵盖的解决方案架构师的角色是AWS解决方案架构师助理。获得这一级认证后，IT人员可以转到专业级认证继续学习。

AWS认证为拥有技术知识的IT专业人员提供了一定程度的认可，它增强了IT人员在设计、操作和部署应用程序和基础设施方面所需的技能。

云计算工程师应该全面了解与云计算有关的每个概念。

IT人士应该对所有的编程语言有全面的了解，其中包括Java，Ruby和Python。除了传统技术外，云计算工程师还应该在现代的基础设施方面具有更多的技能。

大多数寻求云计算工程师的组织都必须要求应聘者具备Docker、Azure、AWS、Rackspace、Linux、Google Compute Engine和OpenStack的操作经验。此外，拥有DevOps和NoSQL数据库的经验也很重要。

云计算-从头到尾(Cloud Computing- Beginning to En)- Ray J. Rafaels著
云计算-实践方法(Cloud Computing- A Hands-on Approach)- Arshdeep Bahga和Vijay Madisetti著
云计算- 概念、技术和架构以及云计算设计模式(Cloud Computing- Concepts. Technology and Architecture and Cloud Computing Design Patterns) – Thomas Erl等人著
Cloudonomics – 云计算的商业价值(Cloudonomics- The Business Value of Cloud Computing) – Joe Weinman著
亚马逊网络服务傻瓜教程(Amazon web services for Dummies)- Bernard Golden著

总而言之，云计算工程师必须通过互联网充分利用所有可用资源，并制定适当的应用程序，以充分拓展他们的职业生涯。

LeetCode-检验两棵树是否相同

LeetCode-检验两棵树是否相同
题目描述
给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
例1：

例2：

例3：

思路
使用树的先序遍历，在根节点值相等的时候再分别比较左子树和右子树，要考虑两棵树结构不同的情况。

代码实现
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
def preorder(p, q):
if not p and not q:
return True
elif not p or not q:
return False
elif p.val == q.val:
a=preorder(p.left, q.left)
b=preorder(p.right, q.right)
return a and b
else:
return False

class Solution(object):
def isSameTree(self, p, q):
“””
:type p: TreeNode
:type q: TreeNode
:rtype: bool
“””
return preorder(p, q)

测试结果

结论
仍需优化。

Python（五）之错误和异常

拿头来坚持的小店 我也想开通小店

实用*新版Python小白零基础入门教程
讲师：暂无

好评：100%

销售量：0
￥45

Python3——入门基础视频教程
讲师：暂无

好评：100%

销售量：0
￥99
更多
申明：资料来源于网络及书本，通过理解、实践、整理成学习笔记。
文章目录
语法错误
异常
处理异常
finally子句
自定义异常
语法错误
在python中如果错误信息以”SynataxError”开头，说明python解释器认为这是一个语法错误，同时会提示你在哪个文件的哪一行开始出错。语法错误通常意味着我们使用python书写格式或者使用方法不正确。

print:

执行结果：
File “E:\Python\Study\error.py”, line 1
print:
^
SyntaxError: invalid syntax

异常
即使python程序的语法是正确的，但是在运行的时候也可能发生一些预想之外的错误。运行时检测到的错误被称为异常，有些错误可能不是致命的，但如果程序员对异常不错处理，python解释器会输出异常到控制台上并终止程序。

python标准异常：

BaseException： 所有异常的基类
SystemExit： 解释器请求退出
KeyboardInterrupt： 用户中断执行(通常是输入^C)
Exception： 常规错误的基类
StopIteration： 迭代器没有更多的值
GeneratorExit： 生成器(generator)发生异常来通知退出
StandardError： 所有的内建标准异常的基类
ArithmeticError： 所有数值计算错误的基类
FloatingPointError： 浮点计算错误
OverflowError： 数值运算超出*大限制
ZeroDivisionError： 除(或取模)零 (所有数据类型)
AssertionError： 断言语句失败
AttributeError： 对象没有这个属性
EOFError： 没有内建输入,到达EOF 标记
EnvironmentError： 操作系统错误的基类
IOError： 输入/输出操作失败
OSError： 操作系统错误
WindowsError： 系统调用失败
ImportError： 导入模块/对象失败
LookupError： 无效数据查询的基类
IndexError： 序列中没有此索引(index)
KeyError： 映射中没有这个键
MemoryError： 内存溢出错误(对于Python 解释器不是致命的)
NameError： 未声明/初始化对象 (没有属性)
UnboundLocalError： 访问未初始化的本地变量
ReferenceError： 弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError： 一般的运行时错误
NotImplementedError： 尚未实现的方法
SyntaxError： Python 语法错误
IndentationError： 缩进错误
TabError： Tab 和空格混用
SystemError： 一般的解释器系统错误
TypeError： 对类型无效的操作
ValueError： 传入无效的参数
UnicodeError Unicode： 相关的错误
UnicodeDecodeError： Unicode 解码时的错误
UnicodeEncodeError： Unicode 编码时错误
UnicodeTranslateError： Unicode 转换时错误
Warning： 警告的基类
DeprecationWarning： 关于被弃用的特征的警告
FutureWarning： 关于构造将来语义会有改变的警告
OverflowWarning： 旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning： 关于特性将会被废弃的警告
RuntimeWarning： 可疑的运行时行为(runtime behavior)的警告
SyntaxWarning： 可疑的语法的警告
UserWarning： 用户代码生成的警告
处理异常
使用try和except关键字捕获异常并让我们运行相应的代码去处理异常。

try:
业务语法块
except 异常类型:
处理异常语法块

在try业务块语法中产生的异常都会终止业务语法块并跳转到except匹配异常类型，如果能匹配上，则运行处理异常的语法块，否则程序报错退出。

number = int(input(‘请输入一个数字：’))
print(number)

执行结果：
请输入一个数字：a
number = int(input(‘请输入一个数字：’))
ValueError: invalid literal for int() with base 10: ‘a’

try:
number = int(input(‘请输入一个数字：’))
print(number)
except ValueError:
print(‘输入了无效的数字’, ValueError)
except Exception as e:
print(‘输出错误’, e)

执行结果：
请输入一个数字：a
输入了无效的数字 <class ‘ValueError’>

上面就是一个处理异常的例子，首先在try中编写我们的业务逻辑代码，然后根据错误类型定义多个异常处理的except语句块。如果有多个except，那么python解释器会逐个匹配except后的异常类型，匹配到则运行相应的处理异常的语法块，没有匹配到则输出异常并退出程序。由于大部分异常都是从Exception这个父类继承过来的，所有匹配的异常类型是Exception，大部分几率是能匹配到异常的。

finally子句
python中的finally子句需要和try子句搭配着一起使用。finally子句在异常处理中的作用是：无论是否有异常或者是否捕获了异常，finally子句都会执行。

for i in range(2):
try:
number = int(input(‘请输入一个数字：’))
print(number)
except Exception as e:
print(‘捕获到了异常’, e)
finally:
print(‘finally子句执行’)

执行结果：
请输入一个数字：1
1
finally子句执行

请输入一个数字：a
捕获到了异常 invalid literal for int() with base 10: ‘a’
finally子句执行

自定义异常
定义我的自定义异常
class MyException(Exception):
def __init__(self):
pass

# 当使用print输出对象的时候，若定义了__str__(self)方法，打印对象时就会从这个方法中打印出return的字符串数据。
def __str__(self):
return ‘我自定义的异常’

# raise语句用来引发一个异常。异常/错误对象必须有一个名字，且它们应是Error或Exception类的子类。
def raise_customer_exception():
raise MyException()

raise_customer_exception()

执行结果：
Traceback (most recent call last):
File “E:\Python\Study\error.py”, line 23, in <module>
raise_customer_exception()
File “E:\Python\Study\error.py”, line 20, in raise_customer_exception
raise MyException()
__main__.MyException: 我自定义的异常

使用我的自定义异常
class MyException(Exception):
def __init__(self):
pass

def raise_customer_exception():
raise MyException()

try:
raise_customer_exception()
except MyException as e:
print(‘自定义的异常’, e)

执行结果：
自定义的异常

云市场的红火，企业也需要相关的技术人员来满足他们的业务需求，因此促使许多IT人员愿意向云计算领域转型。在这之前，我们需要首先了解一下那些受欢迎的云计算岗位，并了解公司雇主对他们的期望。然后，了解自己的简历需要增加哪些经验和技能，如何获取经验，以及如何回答雇主在面试期间提出的一些难题。

以下概述云计算中的一些常见职业以及他们所需的技能：

1、云计算管理员

企业需要工作人员配置云部署并执行管理和监控任务，这个工作人员就是云计算管理者。需要具备坚实的知识基础，通过教育和培训，获得认证，可以为其在云计算领域的职业做好准备，确保其技能是*新的。

管理员的大部分工作是云计算基础设施管理，所以公司的面试人员将询问应聘者的云计算管理体验，以及其熟悉的工具和平台。

企业将会继续积*应用公共和混合云模型，并在谈论将工作负载合并到公共云及其好处。
面试者可能会问应聘人员是否会采用DevOps工具，特别是随着越来越多的企业追求这个模式，它有利于云计算管理员获得DevOps相关工具的经验。

2、云计算架构师

云计算架构师考虑到大局：他们监督云计算策略，包括采用计划，应用程序设计和管理。由于云计算技术不断变化，云计算架构师必须了解当前趋势，以保持环境的有效运行。

企业希望云计算架构师能够面对未来的系统，对于组织三年或三年以上的云战略有着长期的考虑，并可以制定一个更好的路线图，为企业做好充足的准备。

跨平台的可移植性是企业面临的一个重大问题，因此在面试过程中可能会出现容器体验。云计算架构师需要知道容器的能力以及它们如何适应云战略。

3、云计算安全经理

安全性始终是企业的首要关注点，云计算安全管理者的作用是保持云部署安全。应聘者需要通过正式的培训和认证，如认证信息系统安全专家，这是简历的重要方面。虽然坚实的教育基础很重要，但面试人员希望应聘者可以在现实世界中使用这些技能。
在云计算安全方面，应聘者还有很多参与的机会和因素，并必须证明能够设计、执行和维护各种云基础架构的云安全策略。
云计算系统的威胁和风险日益严重，所以管理人员必须不断监控环境。需要跟踪云安全趋势，并掌握不同的工具和流程，如加密、访问控制和多因素身份验证。

管理人员必须具备良好的沟通能力，为组织内的员工制定政策，以及对治理和合规性标准的了解。应聘者需要学习新技能，强化已经拥有或在云计算的新职业技能，这永远不会太晚。云计算领域对人才的需求不断变化，所以面试人员希望应聘者具备与现在不同的技能，以适应将来的需求。

云计算供应商特定的体验、容器、机器学习是三种技能，可以帮助提高应聘者简历的价值。

4、云应用开发人员

企业开发和部署软件的方式随着云计算的发展而不断变化。由于这些变化，企业需要更多的云应用开发人员；他们希望开发人员也承担通常与架构师、工程师、分析师和技术人员联系的角色。不过，应聘者还需要有编程方面的教育背景，请务必了解潜在雇主使用哪些语言，你是否已经掌握了这种语言。

企业雇主需要确保应聘者的技能适合企业，所以他们会询问开发过程。应聘者使用的管理和开发工具越多，面试人员可以评估应聘者是否能够转换到其工具集中。

强调自动化的重要性，敏捷模型在企业中很受欢迎，因此具有这些模型的经验以及不同部门和角色之间的合作能力有着很大的好处。
————————————————

原文链接：https://blog.csdn.net/IT_studied/article/details/108329201

Sen+MK长时间序列趋势性分析—-基于python的代码实现

sen+mk python实现代码免费共享—–赶紧收藏吧
python开源社区公布了进行sen+mk趋势性检验的官方包，有关该官方包的主要内容详见：https://github.com/Coder2cdb/pyMannKendall，开源不易，有些人还收费查看，我觉得没必要，本次代码免费分享给大家，有需要的收藏点赞！

本次sen+mk python代码输入参数：多年影像的存储路径
path1=r”E:\2021-03-03—生态修复\吴起本地\NDVI_wuqi”
本次sen+mk python代码输出参数：结果影像存储路径
result_path=r”E:\小师妹\1990-2000_NDVI\result”
调用方法：
sen_mk_test(path1, result_path)
MannKendall输出参数说明

”
trend: tells the trend (increasing, decreasing or no trend)
h: True (if trend is present) or False (if trend is absence)
p: p-value of the significance test
z: normalized test statistics
Tau: Kendall Tau
s: Mann-Kendal’s score
var_s: Variance S
slope: Theil-Sen estimator/slope
intercept: intercept of Kendall-Theil Robust Line
”’

1.导入python包
#coding:utf-8
import numpy as np
import pymannkendall as mk
import os
import rasterio as ras

2.获取所有的影像路径，按照从小到大年份排序
path1=r”E:\2021-03-03—生态修复\吴起本地\NDVI_wuqi”
filepaths=[]
for file in os.listdir(path1):
filepath1=os.path.join(path1,file)
filepaths.append(filepath1)

3.读取所有的影像数据并拼接为一个numpy矩阵
#获取影像数量
num_images=len(filepaths)
#读取影像数据
img1=ras.open(filepaths[0])
#获取影像的投影，高度和宽度
transform1=img1.transform
height1=img1.height
width1=img1.width
array1=img1.read()
img1.close()

#读取所有影像
for path1 in filepaths[1:]:
if path1[-3:]==’tif’:
print(path1)
img2=ras.open(path1)
array2=img2.read()
array1=np.vstack((array1,array2))
img2.close()

nums,width,height=array1.shape

4.定义输出矩阵
#输出矩阵，无值区用-9999填充
slope_array=np.full([width,height],-9999.0000)
z_array=np.full([width,height],-9999.0000)
Trend_array=np.full([width,height],-9999.0000)
Tau_array=np.full([width,height],-9999.0000)
s_array=np.full([width,height],-9999.0000)
p_array=np.full([width,height],-9999.0000)
#只有有值的区域才进行mk检验，如果所有影像同一像元都为空，则不进行mk检验
c1=np.isnan(array1)
sum_array1=np.sum(c1,axis=0)
nan_positions=np.where(sum_array1==num_images)
positions=np.where(sum_array1!=num_images)
#输出总像元数量
print(“all the pixel counts are {0}”.format(len(positions[0])))

5.sen+mk检验
for i in range(len(positions[0])):
print(i)
x=positions[0][i]
y=positions[1][i]
mk_list1=array1[:,x,y]
trend, h, p, z, Tau, s, var_s, slope, intercept = mk.original_test(mk_list1)
if trend==”decreasing”:
trend_value=-1
elif trend==”increasing”:
trend_value=1
else:
trend_value=0
slope_array[x,y]=slope#senslope
s_array[x,y]=s
z_array[x,y]=z
Trend_array[x,y]=trend_value
p_array[x,y]=p
Tau_array[x,y]=Tau

6.定义写影像的函数
#写影像，包括宽度，高度，投影，波段名，矩阵
def writeImage(image_save_path,height1,width1,para_array,bandDes,transform1):
with ras.open(
image_save_path,
‘w’,
driver=’GTiff’,
height=height1,
width=width1,
count=1,
dtype=para_array.dtype,
crs=’+proj=latlong’,
transform=transform1,
) as dst:
dst.write_band(1,para_array)
dst.set_band_description(1,bandDes)
del dst

7.输出结果
#输出矩阵
all_array=[slope_array,Trend_array,p_array,s_array,Tau_array,z_array]
#输出路径
result_path=r”E:\2021-03-03—生态修复\吴起本地\result”
slope_save_path=os.path.join(result_path,”slope.tif”)
Trend_save_path=os.path.join(result_path,”Trend.tif”)
p_save_path=os.path.join(result_path,”p.tif”)
s_save_path=os.path.join(result_path,”s.tif”)
tau_save_path=os.path.join(result_path,”tau.tif”)
z_save_path=os.path.join(result_path,”z.tif”)
image_save_paths=[slope_save_path,Trend_save_path,p_save_path,s_save_path,tau_save_path,z_save_path]
band_Des=[‘slope’,’trend’,’p_value’,’score’,’tau’,’z_value’]
#逐个存储
for i in range(len(all_array)):
writeImage(image_save_paths[i], height1, width1, all_array[i], band_Des[i],transform1)

sen+mk代码汇总
”’
Created on 2021年4月11日

@author: SunStrong
”’
#coding:utf-8
import numpy as np
import pymannkendall as mk
import os
import rasterio as ras

def sen_mk_test(image_path,outputPath):

#image_path:影像的存储路径
#outputPath:结果输出路径

filepaths=[]
for file in os.listdir(path1):
filepath1=os.path.join(path1,file)
filepaths.append(filepath1)

#获取影像数量
num_images=len(filepaths)
#读取影像数据
img1=ras.open(filepaths[0])
#获取影像的投影，高度和宽度
transform1=img1.transform
height1=img1.height
width1=img1.width
array1=img1.read()
img1.close()

#读取所有影像
for path1 in filepaths[1:]:
if path1[-3:]==’tif’:
print(path1)
img2=ras.open(path1)
array2=img2.read()
array1=np.vstack((array1,array2))
img2.close()

nums,width,height=array1.shape
#写影像
def writeImage(image_save_path,height1,width1,para_array,bandDes,transform1):
with ras.open(
image_save_path,
‘w’,
driver=’GTiff’,
height=height1,
width=width1,
count=1,
dtype=para_array.dtype,
crs=’+proj=latlong’,
transform=transform1,
) as dst:
dst.write_band(1,para_array)
dst.set_band_description(1,bandDes)
del dst

#输出矩阵，无值区用-9999填充
slope_array=np.full([width,height],-9999.0000)
z_array=np.full([width,height],-9999.0000)
Trend_array=np.full([width,height],-9999.0000)
Tau_array=np.full([width,height],-9999.0000)
s_array=np.full([width,height],-9999.0000)
p_array=np.full([width,height],-9999.0000)
#只有有值的区域才进行mk检验
c1=np.isnan(array1)
sum_array1=np.sum(c1,axis=0)
nan_positions=np.where(sum_array1==num_images)

positions=np.where(sum_array1!=num_images)

#输出总像元数量
print(“all the pixel counts are {0}”.format(len(positions[0])))
#mk test
for i in range(len(positions[0])):
print(i)
x=positions[0][i]
y=positions[1][i]
mk_list1=array1[:,x,y]
trend, h, p, z, Tau, s, var_s, slope, intercept = mk.original_test(mk_list1)
”’
trend: tells the trend (increasing, decreasing or no trend)
h: True (if trend is present) or False (if trend is absence)
p: p-value of the significance test
z: normalized test statistics
Tau: Kendall Tau
s: Mann-Kendal’s score
var_s: Variance S
slope: Theil-Sen estimator/slope
intercept: intercept of Kendall-Theil Robust Line
”’

if trend==”decreasing”:
trend_value=-1
elif trend==”increasing”:
trend_value=1
else:
trend_value=0
slope_array[x,y]=slope#senslope
s_array[x,y]=s
z_array[x,y]=z
Trend_array[x,y]=trend_value
p_array[x,y]=p
Tau_array[x,y]=Tau

all_array=[slope_array,Trend_array,p_array,s_array,Tau_array,z_array]

slope_save_path=os.path.join(result_path,”slope.tif”)
Trend_save_path=os.path.join(result_path,”Trend.tif”)
p_save_path=os.path.join(result_path,”p.tif”)
s_save_path=os.path.join(result_path,”s.tif”)
tau_save_path=os.path.join(result_path,”tau.tif”)
z_save_path=os.path.join(result_path,”z.tif”)
image_save_paths=[slope_save_path,Trend_save_path,p_save_path,s_save_path,tau_save_path,z_save_path]
band_Des=[‘slope’,’trend’,’p_value’,’score’,’tau’,’z_value’]
for i in range(len(all_array)):
writeImage(image_save_paths[i], height1, width1, all_array[i], band_Des[i],transform1)

#调用
path1=r”E:\2021-03-03—生态修复\吴起本地\NDVI_wuqi”
result_path=r”E:\2021-03-03—生态修复\吴起本地\result”
sen_mk_test(path1, result_path)

 

控制流作业

# ————————-*题—————————#
number = input(‘请输入一个整数：’)
if (int(number)%7 == 0) | (number.find(‘7’) != -1):
print(‘该数与7相关’)
else:
print(‘该数与7无关’)

# ————————-第二题—————————#
id = input(‘请输入身份证号码：’)
if len(id) == 18:
birthday = id[6:14]
print(‘你的出生日期是：’,birthday)
elif len(id) == 15:
birthday = ’19’ + id[6:12]
print(‘你的出生日期是：’,birthday)
else:
print(‘请重新输入身份证号码！’)

# ————————-第三题—————————#
id = input(‘请输入身份证号码：’)
if len(id) == 18:
if int(id[-2]) % 2 == 0:
print(‘女’)
else:
print(‘男’)
elif (len(id)) == 15:
if int(id[-1]) % 2 == 0:
print(‘女’)
else:
print(‘男’)
else:
print(‘请重新输入身份证号码！’)

# ————————-第四题—————————#
list6 = [1,5,2,8,10,13,17,4,6]
## 方法一：
result = []
for i in list6:
result.append(i**2+1)
print(result)

## 方法二：
result = [i**2+1 for i in list6]
print(result)

# ————————-第五题—————————#
list7 = [‘one’,’two’,’three’,’four’,’five’,’six’,’seven’,’eight’,’nine’]
## 方法一：
result = []
for i in list7:
if i.find(‘e’) != -1:
new_i = i.replace(i[:],’^-^’)
result.append(new_i)
else:
result.append(i)
print(result)

## 方法二：
result = [i for i in list7 if i.find(‘e’)!=-1]
print(result)

#————————-第六题—————————#
# 同第四题

# ————————-第七题—————————#
list8 = [‘A’,’C’,’A’,’C’,’B’,’C’,’A’,’A’,’B’,’C’]
dict = {}
for i in set(list8):
dict[i] = list8.count(i)
print(dict)

# ————————-第八题—————————–#
n = 1
s = 0
while s<=1000:
s += 3*n+5
n += 1
print(n,’–>’,s)

# ————————–第九题—————————–#
import random
A = int(input(‘范围*小值：’))
B = int(input(‘范围*大值：’))
number = random.randint(A,B)

while True:
guess = int(input(‘请在{}、{}之间猜一个整数:’.format(A,B)))
if guess > number:
B = guess
elif guess < number:
A = guess
else:
print(‘你真棒，猜中了。’)
break

2006年3月，亚马逊推出AWS公测版，拉开了云计算IaaS市场的*阶段的竞争，比的是谁先把IaaS“做出来”，并跑通商业模式。

亚马逊在美国东海岸向顾客开放了*批服务器，结果客户们飞快涌入，西海岸的顾客还没来得及接入，*批服务器就已被占满。

同时，亚马逊还靠吐血降价来抢占市场，把Rackspace这样的小体量公司逼到了*境。

亚马逊之所以能狠着劲把云计算的IaaS层做成、跑通，有四个原因：

*，内部需求倒逼。

在2000年之后，亚马逊为了应对每年一次的圣诞大促，被迫购买了太多完全用不上的计算和存储能力，部署了大量冗余的IT资源，花钱多还浪费，急需找到一种更高效调用IT资源的方式。

第二，贝佐斯的“基础设施”信念。

当时，亚马逊创始人贝佐斯对2001年出版的一本名为《创造》的书非常痴迷，让公司高管人人必读。这本书有个理念：*有价值和竞争壁垒、*不可或缺的公司，是那些能够提供类似于水电一样的基础设施服务的公司。

所以在2002年推出的更偏应用层的API服务后，亚马逊在2004年开始着手开发更靠近基础设施层的新服务，这就是两年后推出的AWS。

第三，亚马逊的商业基因。

从基因和气质来说，亚马逊的技术虽然也很强，但起于电商的亚马逊更习惯直接从市场需求打造解决方案，而不是靠技术或产品创造市场需求。且亚马逊一头对接B端商家，一头对接C端消费者，本就有服务B端客户的经验和渠道，能扎实地推进IaaS服务这一新事物的商业化落地。

第四，有钱。

首先，亚马逊的主营业务现金流很好；其次，作为一个备受资本市场青睐的上市公司，亚马逊又能融到很多钱，支持自己的“战略性亏损”。

到2015年，贝佐斯给过去10年作了一个回放：“创建十年来，AWS展现出亚马逊追求理想与敢当风险的*佳例证。我们拿捏着两个视乎矛盾的对立体：一个要立竿见影出结果，另一个则风物长宜放眼量。”

到2008年，经过AWS、Rackspace和之前Salesforce等公司的市场教育，上层的SaaS和底层的IaaS，逐渐融入一个统一的概念：云计算。

其他巨头也看到了具有“水电”般不可或缺的云计算IaaS层的前景。

时任微软CEO史蒂夫·鲍尔默在华盛顿大学的演讲中喊出了这样的口号：“For the cloud, we’re all in.”

直到现在云计算业务都做得不怎么样的谷歌，当时也热心地参与了云计算概念普及和媒体宣传，其云计算业务负责人，还义务跑到高校开课，试图为行业培养长期人才。

但在当时，相比亚马逊的大力投入，其他大公司更多是“口号大于行动”，他们认真下场的时间都在2013年之后。