python 高级语法

*args

arguments,位置参数。传递一个可变长度的参数列表（tuple）给函数实参，将前n个参数给形参后，参数列表剩下的即是参数args。

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

test_args(1, 2, 3, 4)

####
Required argument:  1
<class 'tuple'>
Optional argument:  2
Optional argument:  3
Optional argument:  4

**kwargs

keyword arguments，关键字参数，将一个可变的关键字参数的字典元组传给函数实参。

def test_kwargs(first, *args, **kwargs):
   print('Required argument: ', first)
   print(type(kwargs))
   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)

#### 
Required argument:  1
<class 'dict'>
Optional argument (args):  2
Optional argument (args):  3
Optional argument (args):  4
Optional argument k2 (kwargs): 6
Optional argument k1 (kwargs): 5

 *args、**kwargs直接传入不定长元组

def test_args_kwargs(arg1, arg2, arg3):
    print("arg1:", arg1)
    print("arg2:", arg2)
    print("arg3:", arg3)

input = ("two", 3, 5)
test_args_kwargs(*input)

########
arg1: two
arg2: 3
arg3: 5


input1 = {"arg3": 3, "arg2": "two", "arg1": 5}
test_args_kwargs(**input1)

#########
arg1: 5
arg2: two
arg3: 3

@classmethod

classmethod修饰符对应的函数不需要实例化，不需要self参数，第一个参数需要表示自身类的cls参数，可以用来调用类的属性、方法、实例化对象。

class A(object):
    bar = 1
    def func1(self):  
        print ('foo') 
    @classmethod
    def func2(cls):
        print ('func2')
        print (cls.bar)
        cls().func1()   # 调用 foo 方法
 
A.func2()               # 不需要实例化

##########
func2
1
foo

lamda表达式

省下定义函数的过程，使得代码更简洁

 1 # 普通定义函数
 2 def func1(x,y):
 3     return x+y
 4 # 执行函数
 5 print(func(1,2))
 6 # 如果此函数只调用一次，或者功能简单，此方法就显得笨拙
 7 
 8 
 9 # lambda 
10 g = lambda x,y:x+y
11 print(g(1，2))

map

map(func,iterable)
第一个参数为一个函数，第二个参数为迭代器
迭代器里的每个元素成为函数的参数，遍历迭代器每个元素，传入函数

a=map(lambda x:x*x,[1,2,3,4,5,6]
print(list(a)))        #将map对象转换为list，并打印出结果