Python 难点记录

理解 Python 中的 *args 和 **kwargs

对应函数两种传参形式，一种是直接传入，一种是带参数名的传入

1. 作为参数传入

其中，*args是可变的positional arguments列表，kwargs是可变的keyword arguments列表。并且，*args必须位于kwargs之前，因为positional arguments必须位于keyword arguments之前。

args

def test_args(first, *args):
   print 'Required argument: ', first
   for v in args:
      print 'Optional argument: ', v

test_args(1, 2, 3, 4)
# result:
# Required argument: 1
# Optional argument:  2
# Optional argument:  3
# Optional argument:  4

**kwargs

def test_kwargs(first, *args, **kwargs):
   print 'Required argument: ', first
   for v in args:
      print 'Optional argument (*args): ', v
   for k, v in kwargs.items():
      print 'Optional argument %s (*kwargs): %s' % (k, v)

test_kwargs(1, 2, 3, 4, k1=5, k2=6)
# results:
# Required argument:  1
# Optional argument (*args):  2
# Optional argument (*args):  3
# Optional argument (*args):  4
# Optional argument k2 (*kwargs): 6
# Optional argument k1 (*kwargs): 5

2.在函数调用的时候使用

如果说在函数定义的位置使用*args和**kwargs是一个将参数pack的过程，那么在函数调用的时候就是一个将参数unpack的过程了

def test_args(first, second, third, fourth, fifth):
    print 'First argument: ', first
    print 'Second argument: ', second
    print 'Third argument: ', third
    print 'Fourth argument: ', fourth
    print 'Fifth argument: ', fifth

# Use *args
args = [1, 2, 3, 4, 5]
test_args(*args)
# results:
# First argument:  1
# Second argument:  2
# Third argument:  3
# Fourth argument:  4
# Fifth argument:  5

# Use **kwargs
kwargs = {
    'first': 1,
    'second': 2,
    'third': 3,
    'fourth': 4,
    'fifth': 5
}

test_args(**kwargs)
# results:
# First argument:  1
# Second argument:  2
# Third argument:  3
# Fourth argument:  4
# Fifth argument:  5

3.python类中的 cls self __new__()方法

1 self表示一个具体的实例本身。如果用了staticmethod，那么就可以无视这个self，将这个方法当成一个普通的函数使用。

2 cls 表示类本身 在类方法中使用

>>> class A(object):
        def foo1(self):
            print "Hello",self
        @staticmethod
        def foo2():
            print "hello"
        @classmethod
        def foo3(cls):
            print "hello",cls


>>> a = A()

>>> a.foo1()          #最常见的调用方式，但与下面的方式相同
Hello <__main__.A object at 0x9f6abec>

>>> A.foo1(a)         #这里传入实例a，相当于普通方法的self
Hello <__main__.A object at 0x9f6abec>

>>> A.foo2()          #这里，由于静态方法没有参数，故可以不传东西
hello

>>> A.foo3()          #这里，由于是类方法，因此，它的第一个参数为类本身。
hello <class '__main__.A'>

>>> A                 #可以看到，直接输入A，与上面那种调用返回同样的信息。
<class '__main__.A'>

3.类先调用__new__方法，返回该类的实例对象，这个实例对象就是__init__方法的第一个参数self，即self是__new__的返回值。

4.dictionary 查找元素操作

1. dict.setdefault(key, default=None) --> 有key获取值，否则设置 key:default，并返回default，default默认值为None

2. dict.get(key, default=None) --> 有key获取值，否则返回default。default默认值为None。

5. python中的元组 列表相加

print([1,2]+[2,3])

[1, 2, 2, 3]

print((1,2)+(2,3))

(1,2,2,3)

set dictionary 不可相加

6. 对list 前加*

a = [1,2,3]
print(a,*a)

[1, 2, 3] 1 2 3
可见通过*运算取出了其中的各个元素值
所以我们可以先把模型存入list中之后再放入Sequential中

def vgg_block(num_convs, in_channels, out_channels):
    blk = []
    for i in range(num_convs):
        if i == 0:
            blk.append(nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1))
        else:
            blk.append(nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1))
        blk.append(nn.ReLU())
    blk.append(nn.MaxPool2d(kernel_size=2, stride=2))
    return nn.Sequential(*blk)

set 同list

7. class 中__enter__ __exit__使用

class Benchmark(): 
	def __init__(self, prefix=None):
		self.prefix = prefix + ' ' if prefix else ''
	def __enter__(self):
		self.start = time.time()
	def __exit__(self, *args):
		print('%stime: %.4f sec' % (self.prefix, time.time() -
	self.start))

使用with进行计时器的创建：

with Benchmark('Run on GPU1.'):