开发者社区> 科技探索者> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

python基础---函数

简介:
+关注继续查看

函数


1 函数的概念

a.函数所解决的问题:

复杂度增大、组织结构不清晰、可读性差、代码冗余、可扩展性差


函数就是具备某一种功能的物件

实现准备工具的过程称为函数的定义

遇到特定的场景拿来就用称为函数的调用

 

b.函数的分类:

内置函数

自定义函数

 

2、函数的使用:

先定义

再调用

 

a.函数的定义语法:

def  函数名(arg1,arg2,arg3):

      “注释

      函数体

      return   返回值

 

注意:

函数名一般是动词


b. retrun的使用:

return 返回值没有类型限制


在函数内部可以有多个return,但只能执行一次,函数就结束调用,并且会把return后的值作为函数执行的结果返回


没有return:返回None,等同于return None

return 一个值:返回该值

return 多个值:返回多个值组成的一个元组

 

c.定义的三种形式:


无参:应用场景仅仅只是执行一些操作,比如与用户交互、打印等

有参:需要根据外部传进来的参数,才能执行相应的逻辑操作,比如统计长度,求最大值

空函数:设计代码结构

 

3、函数的调用:


函数调用的三种形式:

a.语句形式

b.表达式形式

c.当做另外一个函数的参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def my_max(x,y):
    if x > y:
        return x
    else:
        return y
 
my_max(1,2#语句形式
 
res=my_max(1,2)*10 #表达式形式
 
# res1=my_max(1,2)     #如果不使用第三种形式要写这两行
# res2=my_max(res1,3)
 
res2=my_max(my_max(1,2),3#函数调用可以当做另外一个函数的参数
print(res2)

练习:

1
2
3
4
5
6
7
8
9
10
11
#定义阶段
def foo():
    print('from foo')
    bar()
# print(foo)
def bar():
    print('from bar')
 
 
#调用阶段
foo()

 

注意:

函数在定义阶段只检测语法,不执行代码

 

4、函数参数


a.参数的形式

形参

实参


1
2
3
4
5
6
7
8
9
10
11
12
#形参:在定义函数时,括号内的参数成为形参
#特点:形参就是变量名
# def foo(x,y): #x=1,y=2
#     print(x)
#     print(y)
 
#实参:在调用函数时,括号内的参数成为实参
#特点:实参就是变量值
# foo(1,2)
 
#在调用阶段实参(变量值)才会绑定形参(变量名)
#调用结束后,解除绑定


b.参数的分类:

位置参数:按照从左到右的顺序依次定义的参数

            位置形参:必须被传值,并且多一个不行,少一个也不行

            位置实参:与形参按照位置一一对应

1
2
3
4
5
6
7
8
9
位置参数:按照从左到右的顺序依次定义的参数
    位置形参:必须被传值,并且多一个不行,少一个也不行
    位置实参:与形参按照位置一一对应
 
def foo(x,y):
    print(x)
    print(y)
 
foo('egon',1,2)


关键字实参:指的是按照name=value的形式,指名道姓地给name传值

注意问题:

           问题一语法规定位置实参必须在关键字实参的前面

               问题二一定不要对同一个形参传多次值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
关键字实参:指的是按照name=value的形式,指名道姓地给name传值
def foo(name,age):
    print(name)
    print(age)
 
foo('egon',18)
foo(age=18,name='egon')
 
关键字实参需要注意的问题是:
def foo(name,age,sex):
    print(name)
    print(age)
    print(sex)
 
foo('egon',18,'male')
print('======>')
foo(sex='male',age=18,name='egon')
foo('egon',sex='male',age=18)
 
问题一:语法规定位置实参必须在关键字实参的前面
foo('egon',sex='male',age=18)
 
问题二:一定不要对同一个形参传多次值
foo('egon',sex='male',age=18,name='egon1')
 
foo('male',age=18,name='egon1')

 

     3 默认形参:在定义阶段,就已经为形参赋值,意味在调用阶段可以不用传值

 

默认参数需要注意的问题:
问题一:默认参数必须放在位置参数之后
问题二:默认参数只在定义阶段赋值一次,而且仅一次
问题三:默认参数的值应该定义成不可变类型

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
默认形参:在定义阶段,就已经为形参赋值,意味在调用阶段可以不用传值
def foo(x,y=1111111):
    print(x)
    print(y)
 
 
foo(1,'a')
 
def register(name,age,sex='male'):
    print(name,age,sex)
 
 
register('asb',73)
register('wsb',38)
register('ysb',84)
register('yaya',28,'female')
 
 
默认参数需要注意的问题
问题一:默认参数必须放在位置参数之后
def foo(y=1,x):
    print(x,y)
 
问题二:默认参数只在定义阶段赋值一次,而且仅一次
x=100
def foo(a,b=x):
    print(a,b)
 
x=111111111111111111111111111111
foo('egon')
 
问题三:默认参数的值应该定义成不可变类型

 

    4 可变长参数:指的是实参的个数不固定

形参必须要两种机制来分别处理实参:

按照位置定义的实参溢出的情况:*

跟按照关键字定义的实参溢出的情况:**

 

处理位置实参:*会把溢出的位置实参保存成元组

1
2
3
4
5
6
7
8
9
10
11
12
13
def foo(x,y,*args): #nums=(3,4,5,6,7)
    print(x)
    print(y)
    print(args)
 
foo(1,2,3,4,5,6,7#*
foo(1,2#*输出结果:
1
2
(34567)
1
2
()


处理关键字实参:**会把溢出的关键字实参保存成字典

1
2
3
4
5
6
7
8
def foo(x,y,**kwargs): #kwargs={'z':3,'b':2,'a':1}
    print(x)
    print(y)
    print(kwargs)
foo(1,2,z=3,a=1,b=2#**输出结果:
1
2
{'z'3'a'1'b'2}


***结合使用

1
2
3
4
def wrapper(*args,**kwargs): #args=(1,2,3) kwargs={'a':1,'b':2}
    print(args)
    print(kwargs)
wrapper(1,2,3,a=1,b=2)


命名关键字参数:在*后面定义的形参称为命名关键字参数,必须是以关键字实参的形式传值

1
2
3
4
5
6
7
8
def foo(name,age,*args,sex='male',group):
    print(name)
    print(age)
    print(args)
    print(sex)
    print(group)
 
foo('alex',18,19,20,300,group='group1')


5、函数对象

函数是第一类的对象:指的是函数可以被当做数据传递

a.被赋值

b.可以当做参数传入

c.可以当做函数的返回

d.可以当做容器类型的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def foo():
    print('from foo')
f=foo          #把函数名赋值给变量
print(f)
f()            #使用变量名可以调用函数
 
def wrapper(func):
    # print(func)
    func()
wrapper(foo)          #把函数名foo当做参数传递给func
 
def wrapper(func):   #把函数名foo当做参数传递给func,func当做return         
    return func               #的返回值
res=wrapper(foo)
print(res)
 
 
cmd_dic={
    'func':foo            #把函数名以value的形式传入字典中
}
 
print(cmd_dic)
 
cmd_dic['func']()


函数练习:


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
1、写函数,,用户传入修改的文件名,与要修改的内容,执行函数,完成批量修改操作
filename=input('请输入你要修改的文件名:')
old=input('请输入你要修改的内容:')
new=input('请输入新内容:')
def modify(filename,old,new):
    import os
    with open(filename,'r',encoding='utf-8') as read_f,\
        open('.bak.swap','w',encoding='utf-8') as write_f:
        for line in read_f:
            if old in line:
                line=line.replace(old,new)
            write_f.write(line)
    os.remove(filename)
    os.rename('.bak.swap',filename)
 
modify(filename,old,new)
 
 
2、写函数,计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
def calculation(str):
    res={
        'nums'0,
        'string'0,
        'space'0,
        'other'0
    }
    for in str:
        if s.isdigit():
            res['nums']+=1
        if s.isalpha():
            res['string']+=1
        if s.isspace():
            res['space']+=1
        else:
            res['other']+=1
    return res
str=input('请输入要判断的字符串:')
res=calculation(str)
print(res)
 
3、写函数,判断用户传入的对象(字符串、列表、元组)长度是否大于5
def judge(object):
    if len(object) >5:
        return object
object=input('请输入字符串、列表或元组:')
judge(object)
 
4、写函数,检查传入列表的长度,如果大于2,那么仅保留前两个长度的内容,并将新内容返回给调用者
def check(str):
    if len(str) >2:
        str=str[0:2]
    return str
str=input('请输入元素:')
print(check(str))
 
5、写函数,检查获取传入列表或元组对象的所有奇数位索引对应的元素,并将其作为新列表返回给调用者
def check_index(objects):
    return objects[::2]
objects=input('请输入列表或元组:')
print(check_index(objects))
 
6、写函数,检查字典的每一个value的长度,如果大于2,那么仅保留前两个长度的内容,并将新内容返回给调用者
dic = {'k1':'v1v1','k2':[11,22,33,44]}
def check_dic(dic):
    d={}
    for key,value in dic.items():
        if len(value) > 2:
            d[key]=value[0:2]
    return d
 
print(check_dic(dic))
本文转自lyndon博客51CTO博客,原文链接http://blog.51cto.com/lyndon/1948661如需转载请自行联系原作者   迟到的栋子

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
5487
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载