Python3---函数基础，匿名函数，内置函数

一.函数.

函数就是对代码进行一个封装。把实现，某一功能的相同代码，进行封装到一起。下次需要使用时，就不需要再进行代码编写，直接调用即可。

好处：函数能提高应用的模块性，和代码的重复利用率。

二.函数的定义

（1）函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
（2）任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
（3）函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
（4）函数内容以冒号起始，并且缩进。

（5）return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

定义方法：

def function_name(params):
        block
        return expression(表达式)/value

def 关键字表示定义一个函数
function_name 函数名，和变量名的命名要求相同，以字母和_开头，可以包含字母、数字和_

params 表示参数，可以是零个，一个 或者多个参数，函数参数不用指定参数类型

三.函数的调用

函数名+()

# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print (str);
   return;
 
# 调用函数
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");

运行结果：

我要调用用户自定义函数!
再次调用同一函数

四.参数形式

（1）不传参

#不传参
def fun1():
    print('不能传参数')

（2）必备参数

#必备参数
def fun2(a):
    print('必须传参数',a)

（3）默认参数

#默认参数
def fun3(b=2):
    print('默认参数',b) #可传可不传

（4）可选参数(*args)

#可选参数
def fun4(*args):
    print('可传0到多个',args )#可传0到多个 包装成元组

>>> fun4()    #不传参
可传0到多个 ()
>>> fun4(1)   #传递一个参数
可传0到多个 (1,)
>>> fun4(1,2,3,4) #传递多个参数
可传0到多个 (1, 2, 3, 4)
>>> fun4([1,2,3])  #传递一个列表
可传0到多个 ([1, 2, 3],)
>>> fun4({'j':1})  #传递一个字典
可传0到多个 ({'j': 1},)
>>> fun4((1,2,3,4)) #传递一个元组
可传0到多个 ((1, 2, 3, 4),)

解包（参数前加 *）:去掉里面的壳，比如{}，[]，（）

>>> fun4(*[1,2])
可传0到多个 (1, 2)
>>> fun4(*{'a':1})
可传0到多个 ('a',)

（5）关键字参数（**kwargs）

def fun5(**kwargs):
    print('关键字参数',kwargs) #包装成字典，可传0个到多个

>>> fun5(a=1,b=2) #遵循变量命名规则
关键字参数 {'a': 1, 'b': 2}   

>>> fun5(**{'a':1})
关键字参数 {'a': 1} 键必须是字符串

可选参数和关键字参数统称为不定长参数

定义方法： def function_name(*args,**kwargs):
    *args 将传入参数包装成元组
    **kwargs将传入参数包装成字典

（6）参数混合时：

参数混合时：关键字参数必须放到最后   根据定义的顺序，确保必备参数能拿到值，且只能拿到一个值

#必备参数+默认参数：默认参数必须在必备参数的后面
def fun6(a,b=1):
    print(a,b)

>>> fun6(1,b=2)
1 2

#例2
def fun8(b,m=1,*args):
    print(b)
    print(m)
    print(args)

>>> fun8(1,3,2,3,4)
1
3
(2, 3, 4)

五.return和lambda匿名函数

return有两个作用：

1.用来返回函数的运行结果，或者调用另外一个函数。比如max()函数

>>> def fun1(a,b):
	if a>b:
		return a	
>>> a=fun1(2,1)
>>> a
2

#不加return时
>>> def fun1(a,b):
	if a>b:
		print(a)		
>>> b = fun1(2,1)
2
>>> b
>>>       #由此可见，不加return时返回的是None

2.函数结束的标志。只要运行了return，就强制结束了函数。return后面的程序都不会被执行。

如果函数中没有写return，其实函数运行结束时，默认执行了 return None

return语句的位置是可选的，不是固定出现再函数的最后，可以自定义在函数中的任何地方。

def fun(a,b):
    #return 'return可以放在任何位置~'  #函数结束的标志，可以放在任何地方
     if a > b :
        print(a)
        return 'return可以放在任何位置~'
print(fun(10,2))

#运行结果
10
return可以放在任何位置~

lambda匿名函数：

没有函数名的函数
g = lambda x:x+1

lambda简化了函数定义的书写形式。是代码更为简洁，但是使用函数的定义方式更为直观，易理解 

def fun(a):
    return(a+1)

g相当于fun这个函数体，lambda相当于fun()，x 相当于fun函数里的参数a，冒号后面的x+1相当于return后面的a+1

lambda的应用场景：

1.有些函数如果只是临时一用，而且它的业务逻辑也很简单时，就没必要用def 来定义，这个时候就可以用lambda。

2.函数都支持函数作为参数，lambda 函数就可以应用

六.内置函数

（1）常见的简单内置函数

内置对象查看：dir(__builtins__)

常见函数

len	求长度
min	求最小值
max	求最大值
sorted	排序
reversed	反向
sum	求和

进制转换函数：

bin	转换为二进制
oct	转换为八进制
hex	转换为十六进制
ord	字符转ASCII码
chr	ASCII码转字符

（2）高级内置函数

1.enumerate    返回一个可以枚举的对象

enumerate([1,2,3]) #
list(enumerate([1,2,3]))#返回一个枚举对象（索引，值）索引可以自定义   [(0, 1), (1, 2), (2, 3)]
dict(enumerate(['a','b','c'],2))#{2: 'a', 3: 'b', 4: 'c'} 

2.eval     
取出字符串中的内容
将字符串str当成有效的表达式来求值并返回计算结果

详情请参考：

 http://lib.csdn.net/mobile/article/python/62300 

http://www.runoob.com/python/python-func-eval.html

3.exec     执行字符串或complie方法编译过的字符串

http://www.runoob.com/python3/python3-func-exec.html

4.filter    过滤器

filter(None,[1,2,3])#
list(filter(lambda x:x>1,[1,2,3]))
'''
给定一个过滤的函数当参数，过滤可迭代对象

'''

5.map 对于参数iterable中的每个元素都应用fuction函数，并将结果作为列表返回(加工)

list(map(lambda x:x+1,[1,2,3,4]))#[2, 3, 4, 5]
list(map(str,[1,2,3,4]))#['1', '2', '3', '4']

6.zip    将对象逐一配对

list(zip([1,2,3])) #[(1,), (2,), (3,)]
list(zip([1,2,3],['a','b','c']))#[(1, 'a'), (2, 'b'), (3, 'c')]
list(zip([1,2,3],['a','b','c'],(11,22,33)))

练习1：

找到1-100以内的质数，用while和for来做，找完后打印出“搜索结束”

#for
li = []
for i in range(1,101):
    for j in range(2,i):
        if i%j==0:
            break
    else:
        li.append(i)
else:
    print(li)
    print('搜索结束')

#while
li = []
j=2
while j<101:
    for i in range(2,j):
        if j%i==0:
            break
    else:
        li.append(j)
    j+=1
else:
    print(li)
    print('搜索结束')

练习2：

定义一个函数，能够输入字典和元组，将字典的值和元组的值交换

tu = (1,2,3)
di = {'a':11,'b':22,'c':33}
def exchange(*args,**kwargs):
    args = list(args)
    i = 0
    for key in kwargs.keys():
        args[i],kwargs[key] = kwargs[key],args[i]
        i+=1
        
    print(kwargs)
    print(tuple(args))

exchange(*tu,**di)

#运行结果
{'a': 1, 'b': 2, 'c': 3}
(11, 22, 33)

（2）利用zip函数

tu = (1,2,3)
di = {'a':11,'b':22,'c':33}
def exchange(a,b):
    c = a.values()
    return dict(zip(a,b)),tuple(c)

print(exchange(di,tu))

#运行结果
({'a': 1, 'b': 2, 'c': 3}, (11, 22, 33))

练习3：

定义一个函数，必须包含四种参数形式，然后打印这四个参数，最后返回“OK”

def fun(b,m=1,*arg,**kwarg):
    print('必备参数',b)
    print('默认参数',m)
    print('不定长参数',arg)
    print('关键字参数',kwarg)
    return 'ok'

>>> fun(1,2,1,2,3,x=1,y=2,z=3)
必备参数 1
默认参数 2
不定长参数 (1, 2, 3)
关键字参数 {'x': 1, 'y': 2, 'z': 3}
'ok'