python 函数

Python3---函数基础，匿名函数，内置函数
2018年04月15日 17:09:39 阅读数：69更多
个人分类： Python
一.函数.
函数就是对代码进行一个封装。把实现，某一功能的相同代码，进行封装到一起。下次需要使用时，就不需要再进行代码编写，直接调用即可。

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

二.函数的定义
（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
[python] view plain copy
<code class="language-python">#不加return时
>>> def fun1(a,b):
if a>b:
print(a)
>>> b = fun1(2,1)
2
>>> b
>>> #由此可见，不加return时返回的是None</code>
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]) #<enumerate object at 0x00000000033A4F78>
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])#<filter object at 0x000001E052827FD0>
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'