版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
人工智能AI：Keras PyTorch 深度学习实战（不定时更新）
1.*和**
1.数学运算中，*为乘，**为次方
2.当函数接收元组参数时，使用“*args”。当函数接收字典参数时，使用“**args”。这种方法在函数需要获取可变数量的参数时特别有用。
如果使用的是*作前缀，多余的函数参数都会作为一个元组存储在args中。如果使用的是**作前缀，多余的参数则会被认为是一个字典的健/值对。
3.对于def func(*args)，*args表示把传进来的位置参数存储在tuple(元组)类型的args里面。例如，调用func(1, 2, 3)，args就表示(1, 2, 3)这个元组。
4.对于def func(**args)，**args表示把参数作为字典的健-值对存储在dict(字典)类型的args里面。例如，调用func(a='I',b='am',c='wcdj')，
args就表示{'a':'I', 'b':'am', 'c':'wcdj'}这个字典。
5.注意普通参数与*和**参数同时使用的情况，一般将*args和**args放在参数列表最后。
6.*args 例子
def powersum(power, *args):
total=0
for i in args:
total+=pow(i,power)
return total
powersum(2, 3, 4) #25
powersum(2, 10) #100
7.**args 例子
def findad(username, **args):
print 'Hello: ', username
for name, address in args.items():
print 'Contact %s at %s' % (name, address)
findad('wcdj',gerry='[email protected]',wcdj='[email protected]', yj='[email protected]')
#Hello: wcdj
#Contact gerry at [email protected]
#Contact wcdj at [email protected]
#Contact yj at [email protected]
2.%
1.%是一个运算符号，求余数。求模运算，相当于mod，也就是计算除法的余数，比如5%2就得到1。
2.%是一个格式符。python中%常用的操作有%s,%d,%r等。%s,%r,%d分别表示字符串以str()，rper(),以及十进制整数表示，%f表示结果为浮点型。
1.%f 浮点型
import math
# %a.bf，a表示浮点数的打印长度，b表示浮点数小数点后面的精度 ，%f时表示原值，默认是小数点后5位数
print "PI=%f" % math.pi
output: PI=3.141593
# 只是%9f时，表示打印长度9位数，小数点也占一位，不够左侧补空格
print "PI=%9f" % math.pi
output: PI=_3.141593
2.%d 整型
[python] view plain copy
num=14
#%d打印时结果是14
3.%s 字符串
a = 'test'
print 'it is a %s' %(a)
打印的结果就是 it is a test
3.log()
import math
math.log(x[, base])
log() 返回 x 的自然对数。log()是不能直接访问的，需要导入 math 模块，通过静态对象调用该方法。
参数：
x 数值表达式。
base 可选，底数，默认为 e。
返回值：返回 x 的自然对数，x > 0。
例子：
import math
math.log(100.12) # 4.6063694665635735
math.log(100.72) # 4.612344389736092
math.log(math.pi) # 1.1447298858494002
math.log(10,2) # 3.3219280948873626
4.slice()
slice(stop) 相当于 slice(None, stop, None) 切片操作，默认从第一个元素开始截取到stop元素位置为止
slice(start, stop[, step]) 切片操作，默认从start元素位置开始截取到stop元素位置为止，步长是可选操作
函数实现切片对象，主要用在切片操作函数里的参数传递
参数：
start 起始位置
stop 结束位置
step 间距
返回值：返回一个切片对象
例子：
myslice = slice(5)
myslice # slice(None, 5, None)
arr = range(10)
arr #range(0, 10)
arr[myslice] # range(0, 5)
5.OrderedDict类
1.OrderedDict 也是 dict 的子类，其最大特征是，它可以“维护”添加 key-value 对的顺序。
简单来说，就是先添加的 key-value 对排在前面，后添加的 key-value 对排在后面。
由于 OrderedDict 能维护 key-value 对的添加顺序，因此即使两个 OrderedDict 中的 key-value 对完全相同，但只要它们的顺序不同，
程序在判断它们是否相等时也依然会返回 false。
2.例子
from collections import OrderedDict
# 创建OrderedDict对象
dx = OrderedDict(b=5, c=2, a=7)
print(dx) # OrderedDict([('b', 5), ('c', 2), ('a', 7)])
d = OrderedDict()
# 向OrderedDict中添加key-value对
d['Python'] = 89
d['Swift'] = 92
d['Kotlin'] = 97
d['Go'] = 87
# 遍历OrderedDict的key-value对
for k,v in d.items():
print(k, v)
上面程序首先创建了 OrderedDict 对象，接下来程序向其中添加了 4 个 key-value 对，OrderedDict 完全可以“记住”它们的添加顺序。
运行该程序，可以看到如下输出结果：
OrderedDict([('b', 5), ('c', 2), ('a', 7)])
Python 89
Swift 92
Kotlin 97
Go 87
3.例子
正如前面所说的，两个 OrderedDict 中即使包含的 key-value 对完全相同，但只要它们的顺序不同，程序也依然会判断出两个 OrderedDict 是不相等的。
例如如下程序：
# 创建普通的dict对象
my_data = {'Python': 20, 'Swift':32, 'Kotlin': 43, 'Go': 25}
# 创建基于key排序的OrderedDict
d1 = OrderedDict(sorted(my_data.items(), key=lambda t: t[0]))
# 创建基于value排序的OrderedDict
d2 = OrderedDict(sorted(my_data.items(), key=lambda t: t[1]))
print(d1) # OrderedDict([('Go', 25), ('Kotlin', 43), ('Python', 20), ('Swift', 32)])
print(d2) # OrderedDict([('Python', 20), ('Go', 25), ('Swift', 32), ('Kotlin', 43)])
print(d1 == d2) # False
上面程序先创建了一个普通的 dict 对象，该对象中包含 4 个 key-value 对；接下来程序分别使用 sorted() 函数对 my_data（dict 对象）的 items 进行排序：
d1 是按 key 排序的；d2 是按 value 排序的，这样得到的 d1、d2 两个 OrderedDict 中的 key-value 对是一样的，只不过顺序不同。
运行上面程序，可以看到如下输出结果：
OrderedDict([('Go', 25), ('Kotlin', 43), ('Python', 20), ('Swift', 32)])
OrderedDict([('Python', 20), ('Go', 25), ('Swift', 32), ('Kotlin', 43)])
False
从上面的输出结果可以看到，虽然两个 OrderedDict 所包含的 key-value 对完全相同，但由于它们的顺序不同，因此程序判断它们不相等。
4.例子
此外，由于 OrderedDict 是有序的，因此 Python 为之提供了如下两个方法：
1.popitem(last=True)：默认弹出并返回最右边（最后加入）的 key-value 对；如果将 last 参数设为 False，则弹出并返回最左边（最先加入）的 key-value 对。
2.move_to_end(key, last=True)：默认将指定的 key-value 对移动到最右边（最后加入）；
如果将 last 改为 False，则将指定的 key-value 对移动到最左边（最先加入）。
下面程序示范了 OrderedDict 的两个方法的用法：
from collections import OrderedDict
d = OrderedDict.fromkeys('abcde')
# 将b对应的key-value对移动到最右边（最后加入）
d.move_to_end('b')
print(d.keys()) # odict_keys(['a', 'c', 'd', 'e', 'b'])
# 将b对应的key-value对移动到最左边（最先加入）
d.move_to_end('b', last=False)
print(d.keys()) # odict_keys(['b', 'a', 'c', 'd', 'e'])
# 弹出并返回最右边（最后加入）的key-value对
print(d.popitem()[0]) # e
# 弹出并返回最左边（最先加入）的key-value对
print(d.popitem(last=False)[0]) # b
运行上面程序，可以看到如下输出结果：
odict_keys(['a', 'c', 'd', 'e', 'b'])
odict_keys(['b', 'a', 'c', 'd', 'e'])
e
b
通过上面的输出结果可以看出，使用 OrderedDict 的 move_to_end() 方法可以方便地将指定的 key-value 对移动到 OrderedDict 的任意一端；
而 popitem() 方法则可用于弹出并返回 OrderedDict 任意一端的 key-value 对。