>>> def f(a):a=99>>> b=88
>>> f(b)
>>> print(b)
88
>>> def ch(a,b):a=2b[0]='eoe'>>> x=1
>>> l=[1,2]
>>> ch(x,l)
>>> x,l
(1, ['eoe', 2])
>>> x=1
>>> a=x
>>> a=2
>>> print(x)
1
>>> l=[1,2]
>>> b=l
>>> b[0]='eoe'
>>> print(l)
['eoe', 2]
>>> l=[1,2]
>>> ch(x,l[:])
>>> l
[1, 2]
>>> l1=[2,3,4]
>>> l2=l1
>>> l1[0]=24
>>> l1,l2
([24, 3, 4], [24, 3, 4])
>>> l1=[2,3,4]
>>> l2=l1[:]
>>> l1[0]=24
>>> l1,l2
([24, 3, 4], [2, 3, 4])
>>> def ch(a,b):b=b[:]a=2b[0]='cho'>>> x=1
>>> l=[1,2]
>>> ch(x,l)
>>> l
[1, 2]
>>> x
1
>>> def f(a,b,c):print(a,b,c)>>> f(1,2,3)
1 2 3
>>> f(c=3,b=2,a=1)
1 2 3
>>> def f(a,b=2,c=3):print(a,b,c)>>> f(1)
1 2 3
>>> f(a=1)
1 2 3
>>> f(1,4)
1 4 3
>>> f(6,7,8)
6 7 8
>>> f(1,c=9)
1 2 9
>>> def f(*args):print(args)>>> f()
()
>>> f(1)
(1,)
>>> f(1,2,3,4)
(1, 2, 3, 4)
>>> def f(**args):print(args)>>> f()
{}
>>> f(a=1,b=2)
{'a': 1, 'b': 2}
>>> def f(a,*b,**c):print(a,b,c)>>> f(1,2,3,x=1,y=2)
1 (2, 3) {'x': 1, 'y': 2}
>>> def min1(*args):res=args[0]for arg in args[1:]:if arg < res:res=argreturn res>>> def min2(first,*res):for arg in res:if arg<first:first = argreturn first>>> def min3(*args):tmp=list(args)tmp.sort()return tmp[0]>>> print(min1(4,3,5,1))
1
>>> print(min2('a','b','c','d'))
a
>>> print(min3([1,2,3],[3,2],[1,4,5]))
[1, 2, 3]
>>> def minmax(test,*args):res=args[0]for arg in args[1:]:if test(arg,res):res=argreturn res>>> def less(x,y):return x<y>>> def great(x,y):return x>y>>> print(minmax(less,1,3,2,4,6,7,5))
1
>>> print(minmax(great,1,3,2,4,6,7,5))
7
>>> def intersect(*args):res=[]for x in args[0]:for other in args[1:]:if x not in other:breakelse:res.append(x)return res>>> def union(*args):res=[]for seq in args:for x in seq:if not x in res:res.append(x)return res>>> s1,s2,s3='aaa','bbb','ccc'
>>> s1,s2,s3='aabbcdf','bcfff','aadsxxs'
>>> intersect(s1,s2),union(s1,s2)
(['b', 'b', 'c', 'f'], ['a', 'b', 'c', 'd', 'f'])
>>> intersect([1,2,3,4,5],(1,2,9,8))
[1, 2]
>>> intersect(s1,s2,s3)
[]
>>> union(s1,s2,s3)
['a', 'b', 'c', 'd', 'f', 's', 'x']
>>> def func(x,y,z):return x+y+z>>> func(2,3,4)
9
>>> f=lambda x,y,z:x+y+z
>>> 
>>> f(2,3,4)
9
>>> x=(lambda a='aad',b='bbc',c='ccc':a+b+c)
>>> x('ddd')
'dddbbcccc'
>>> def kk():t='ook'ac=(lambda x : t+' '+x)return ac>>> a=kk()
>>> a('ioi')
'ook ioi'
>>> L=[lambda x : x**2,lambda x : x**3,lambda x : x**4]
>>> for f in L:print(f(2))4
8
16
>>> print(L[0](3))
9
>>> def f1(x):return x**2>>> def f2(x):return x**3>>> def f3(x):return x**4>>> L=[f1,f2,f3]
>>> for f in L:print(f(2))4
8
16
>>> print(L[0](3))
9
>>> key = 'qq'
>>> {'aa':(lambda:2+1),'bb':(lambda:2*2),'qq':(lambda:2*3)}[key]()
6
>>> def f1():return 2+2>>> def f1():return 2+1>>> def f2():return 2*2>>> def f3():return 2*3>>> key='qq'
>>> {'aa':f1,'bb':f2,'qq':f3}[key]()
6
>>> def ac(x):return (lambda y:x+y)>>> act=ac(1)
>>> act(2)
3
>>> ac=(lambda x :(lambda y : x+y))
>>> a=ac(1)
>>> a(2)
3
>>> com=[1,2,3,4]
>>> da=[]
>>> for x in com:da.append(x+10)>>> da
[11, 12, 13, 14]
>>> def inc(x):return x+10>>> list(map(inc,com))
[11, 12, 13, 14]
>>> list(map((lambda x :x+10),com))
[11, 12, 13, 14]
>>> def mymap(func,se):res=[]for x in se:res.append(func(x))return res>>> list(map(inc,[1,2,3]))
[11, 12, 13]
>>> mymap(inc,[1,2,3])
[11, 12, 13]
>>> list(map(pow,[1,2,3],[2,3,4]))
[1, 8, 81]
>>> list(range(-5,5))
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
>>> list(filter((lambda x : x>0),range(-5,5)))
[1, 2, 3, 4]
>>> re=[]
>>> for x in range(-5,5):if x >0:re.append(x)>>> re
[1, 2, 3, 4]
>>> from functools import reduce
>>> reduce((lambda x,y:x+y),[1,2,3,4])
10
>>> reduce((lambda x,y:x*y),[1,2,3,4])
24
>>> L=[1,2,3,4]
>>> re=L[0]
>>> for x in L[1:]:re=re+x>>> re
10

python函数之参数

1.参数共享和引用：

函数中对可变对象参数在原处修改能够影响调用者(列表，字典)，但是对于不可变对象，将其赋值给一个参数，在函数内修改这个参数，对于这个对象本身没有影响。

2.避免可变参数修改：

python中，默认通过引用（引用）进行函数的参数传递。

如果是赋值语句：L1=[1,2,3] L2=L1 那么此时L2和L1引用了相同的对象。此时改变L1，L2也会跟着改变。

但如果是通过拷贝对象，而不是创建相同的引用，此时对L1的修改，不会影响L2的值。因为L2引用的是L1所引用对象的一个拷贝。

L1=[1,2,3] L2=L1[:]

因此，由上述可看出，我们在函数中避免可变参数修改有两种方法：

第一个就是在调用时对列表进行拷贝，另外一个就是直接在函数内部加一个拷贝语句。

4.python中的赋值：

等号左边是变量名，右边是对象，他们之间是通过引用进行联系的。

对于不可变对象来说，给一个变量赋一个新的值，并不是替换了原始对象，而是让这个变量去引用完全不同的一个对象。对一个变量赋值，仅仅会影响那个被赋值的变量。

a=3 b=a a='oo’此时输出b，仍然是3

4.关键字参数：

如果没有特殊的匹配语法，python默认通过位置从左到右匹配变量名。

如果有关键字参数，那么通过变量名进行匹配，而不是通过位置（参数从左至右的关系不再重要）。关键字参数起到了数据标签的作用，可读性增加

5.默认参数：

默认参数允许创建函数可选的参数。如果没有传入值的话，在函数运行前，参数就被赋了默认值。

6.接收任意数目参数：

有两个，第一个是*：将所有位置相关的参数收集到一个新元组里。

另一个是**：只对关键字参数有效，将关键字参数传递给一个新的字典里。

7.函数也能作为参数对象传入另一个函数。

python的lambda表达式：

1.lambda返回一个函数，lambda是一种生成函数对象的表达式，不是一个语句。只能在里面封装有限的逻辑。但是def则是在头部将一个新的函数赋值给一个变量名，而不是将这个函数作为结果返回。

2.默认参数也能够在lambda参数中使用。lambda主体中的代码遵循LEGB法则。

3.lambda表达式能够在使用的代码内嵌入一个函数的定义，使代码结构更为简洁。而且如果再利用字典，通过键索引来取回一个函数，相比if语句更为简洁。从而使字典成为多路分支工具

4.lambda出现在def中，在上层函数调用时候，嵌套的lambda能够获取上层函数作用域中变量名x的值。而且lambda也能够获取任意上层lambda中变量名。

函数工具：map，filter，reduce

1.map函数：对一个序列对象中每个元素应用被传入的函数，返回一个包含所有函数返回结果的一个列表。map想要一个函数传进来，这时候lambda表达式就可以写进去了。而且map里面还能够以多个序列作为参数，返回一个结果列表，每个序列中的元素分别对应函数的一个个参数。

2.filter函数：基于某一测试函数过滤出一些元素。

3.reduce函数：返回一个单一的结果，每个元素都运行函数，一般用于迭加或迭乘。