python 函数（二）

format()格式化函数

eg:
“{} {}”.format(“hello”,“world”) 输出 ‘hello world’
‘{}/tracking_results/’.format(’/mnt/dev_sdc1/wenmei_tracking/tracking/pytracking/pytracking’)
输出 ‘/mnt/dev_sdc1/wenmei_tracking/tracking/pytracking/pytracking/tracking_results/’

dir()

不带参数时，返回当前范围内的变量、方法和定义的类型列表；
带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

#定义一个类
class EnvSettings:
  def __init__(self):
  path=os.path.abspath(os.path.dirname(__file__))
  self.results_path='/aaa/bbb'
  self.network_path='/aaa/ccc'
  self.otb_path=''

当使用
settings=EnvSettings()
for attr in **dir**(settings)
attr 返回为__class__   __ delattr __   __ dict __   __ doc __   __ eq __   __ format __   __ ge __   __ getattribute __   gt __   __ hash __   __ init __   __ init_subclass __   __ le __   __ lt   __ module__   __ ne __   __ new __   __ reduce __ … ‘results_path’   ‘network_path’

getattr()

用于返回一个对象属性值。
接着上面的类分析
当使用 getattr(settings,attr) 会得到相应的值’/aaa/bbb’   ‘/aaa/ccc’   ’ ’

callable()

用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。对于函数、方法、lambda 函式、 类以及实现了 __ call __ 方法的类实例, 它都返回 True。
eg:
callable(’’)结果返回False
callable(“runoob”)结果返回False

importlib.import_module()

动态导入模块

splitlines()、split()

(1)按照行界符(’\r’, ‘\r\n’, \n’等)分隔，返回一个包含各行作为元素的列表，默认不包含行界符。
eg:

print('I\nEnjoy\nLosing\nFace'.splitlines())#字符串以换行符为分隔符拆分，去掉换行符
 #得到的结果为['I', 'Enjoy', 'Losing', 'Face']

(2)str.split(str="", num=string.count(str)).
通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串

reshape(-1,4)

假设你有a=[1 2 3 4 5 6 7 8 ]这样的一维数组，你只想让a变成4列的二维数组。按照常规的reshape,你得计算他的行数，经计算reshape的参数为reshape(2,4)。而使用reshape(-1,4),他会利用a和4列，计算出行数为2。
那 reshape(-1) 呢？将一个二维数组展开为一维

a[:-4]

matplotlib

参考

from collections import OrderedDict

在python中，dict这个数据结构由于hash的特性，是无序的，当你想获得有序的字典对象时，可以使用collection模块提供的OrderedDict

numpy linalg模块

此模块包含线性代数(linear algebra)的函数，可以计算逆矩阵，求特征值，解线性方程组以及求解行列式等
np.linalg.inv() 计算逆矩阵（矩阵必须是方阵，即m*m）

import numpy as np
a=np.array([[1,2],[-1,-3]])
print(np.linalg.inv(a))
#结果为:
[[ 3.  2.]
 [-1. -1.]]
#如果是矩阵对象的话，直接.I来求逆
A=np.mat(a)
print（A.I）#最后的结果和上面一样
#注：注：矩阵必须是方阵且可逆，否则会抛出LinAlgError异常。

当矩阵不可逆，或者是奇异矩阵时，怎么求逆矩阵呢？吴恩达老师的视频，给出的方法是，删除冗余的、或者其他一些不必要的特征，此外也可以使用正则化。在matlab中可以用pinv()函数来求伪逆，那在python中呢？就是下面讲到的奇异矩阵分解。
np.linalg.svd() 计算奇异矩阵分解，任意矩阵
参考 瞬间明白
参考2 加深印象
np.linalg.eigh() 计算特征值和特征向量，要求是实对称矩阵

numpy中的.ravel()和.flatten()

首先两者所要实现的功能是一致的（将多维数组降位一维）。这点从两个单词的意也可以看出来，ravel(散开，解开)，flatten（变平）。两者的区别在于返回拷贝（copy）还是返回视图（view），numpy.flatten()返回一份拷贝，对拷贝所做的修改不会影响（reflects）原始矩阵，而numpy.ravel()返回的是视图（view，也颇有几分C/C++引用reference的意味），会影响（reflects）原始矩阵。
参考链接

shape(2,2)和shape(2,)

x[1,2]的shape值(2,)，意思是一维数组，数组中有2个元素

y[[1],[2]]的shape值是(2,1)，意思是一个二维数组，2行1列

range()

NameError:name ‘xrange’ is not defined
在Python 3中range()与xrange()已经合并为range()了

>>>range(7)
range(0,7)
>>>list(range(7))
[0,1,2,3,4,5,6]

itertools.product()

求笛卡尔积。
笛卡尔积的符号化为：
A×B={(x,y)|x∈A∧y∈B}
例如，A={a,b}, B={0,1,2}，则
A×B={(a, 0), (a, 1), (a, 2), (b, 0), (b, 1), (b, 2)}
B×A={(0, a), (0, b), (1, a), (1, b), (2, a), (2, b)}

报错：IndentationError:expected an indented block
意思是：缩进错误： 期望一个缩进的块
继续执行，还发现报错:SyntaxError: invalid syntax
怎么会有语法错误呢，然后瞪大我的卡姿兰大眼睛一看，原来字符没有加引号，真的是瞎呀

from multiprocessing import Pool

实现多进程并行。
同步执行
Pool.map() 和 Pool.starmap()
.map() 会使进程阻塞，即通过 map() 开启的多进程都结束之后，这个函数才会有返回结果，否则主进程会一直等待，不会往下进行 。与 map 的区别在于， starmap 支持将多个参数放入到队列中。
异步执行
Pool.map_async() 和Pool.starmap_async()
.map_async() 为非阻塞，即通过 map_async() 开启多进程之后，立刻会返回结果，主进程会继续往下执行。

torch.matmul（）

矩阵乘法。torch.mm的broadcast版本。
参考

argparse中的parse_args()

import argparse  #引入模块
parser=argparse.ArgumentParser()  #建立解析对象
parser.add_argument('-s', '--seq', default='DragonBaby')#增加属性，参数简写，在程序内部使用seq，在命令行中用“-s”
parser.add_argument('-f', '--savefig', action='store_true')#action = "store_true" 默认操作True 
#有类型type，并设置了help,"--"表示可选参数，default表示默认值
parser.add_argument('--tracker_name', type=str,default='atom', help='Name of tracking method.')
args=parser.parse_args()

* args,**kwargs:

经常会碰到这两个参数，
def initialize(self,image,state,*args,**kwargs):
args: {tuple} <class ‘tuple’>
kwargs: {dict} <class ‘dict’>

view(1,-1,1,1)

self.mean=torch.Tensor([0.485,0.456,0.406]).view(1,-1,1,1)
shape : torch.Size([1,3,1,1])
那view（1,1,1,-1）呢，变成shape: torch.Size([1,1,1,3])

torch.prod()

元素乘积，返回输入张量input所有元素的乘积。

[10]*6

返回的结果是：[10,10,10,10,10,10]

itertools.permutations

返回课迭代对象的所有全排列的方式

torch.linspace()

torch.linspace(start, end, steps=100, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) → Tensor
函数的作用是，返回一个一维的tensor（张量），这个张量包含了从start到end（包括端点）的等距的steps个数据点