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码
chrASCII码转字符

(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'











阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页