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
( 3 4 5 6 7 )
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如需转载请自行联系原作者   迟到的栋子
目录
打赏
0
0
0
0
89
分享
相关文章
|
3月前
|
【python从入门到精通】-- 第五战:函数大总结
【python从入门到精通】-- 第五战:函数大总结
112 0
利用Python内置函数实现的冒泡排序算法
在上述代码中,`bubble_sort` 函数接受一个列表 `arr` 作为输入。通过两层循环,外层循环控制排序的轮数,内层循环用于比较相邻的元素并进行交换。如果前一个元素大于后一个元素,就将它们交换位置。
152 67
|
22天前
|
[oeasy]python057_如何删除print函数_dunder_builtins_系统内建模块
本文介绍了如何删除Python中的`print`函数,并探讨了系统内建模块`__builtins__`的作用。主要内容包括: 1. **回忆上次内容**:上次提到使用下划线避免命名冲突。 2. **双下划线变量**:解释了双下划线(如`__name__`、`__doc__`、`__builtins__`)是系统定义的标识符,具有特殊含义。
27 3
|
25天前
|
深入理解 Python 的 eval() 函数与空全局字典 {}
`eval()` 函数在 Python 中能将字符串解析为代码并执行,但伴随安全风险,尤其在处理不受信任的输入时。传递空全局字典 {} 可限制其访问内置对象,但仍存隐患。建议通过限制函数和变量、使用沙箱环境、避免复杂表达式、验证输入等提高安全性。更推荐使用 `ast.literal_eval()`、自定义解析器或 JSON 解析等替代方案,以确保代码安全性和可靠性。
34 2
[oeasy]python061_如何接收输入_input函数_字符串_str_容器_ 输入输出
本文介绍了Python中如何使用`input()`函数接收用户输入。`input()`函数可以从标准输入流获取字符串,并将其赋值给变量。通过键盘输入的值可以实时赋予变量,实现动态输入。为了更好地理解其用法,文中通过实例演示了如何接收用户输入并存储在变量中,还介绍了`input()`函数的参数`prompt`,用于提供输入提示信息。最后总结了`input()`函数的核心功能及其应用场景。更多内容可参考蓝桥、GitHub和Gitee上的相关教程。
10 0
|
1月前
|
Python中的函数是**一种命名的代码块,用于执行特定任务或计算
Python中的函数是**一种命名的代码块,用于执行特定任务或计算
60 18
Seaborn 教程-绘图函数
Seaborn 教程-绘图函数
77 8
|
1月前
|
Python中的函数
Python中的函数
54 8
Python中的装饰器:解锁函数增强的魔法####
本文深入探讨了Python语言中一个既强大又灵活的特性——装饰器(Decorator),它以一种优雅的方式实现了函数功能的扩展与增强。不同于传统的代码复用机制,装饰器通过高阶函数的形式,为开发者提供了在不修改原函数源代码的前提下,动态添加新功能的能力。我们将从装饰器的基本概念入手,逐步解析其工作原理,并通过一系列实例展示如何利用装饰器进行日志记录、性能测试、事务处理等常见任务,最终揭示装饰器在提升代码可读性、维护性和功能性方面的独特价值。 ####
|
2月前
|
Python中的`range`函数与负增长
在Python中,`range`函数用于生成整数序列,支持正向和负向增长。本文详细介绍了如何使用`range`生成负增长的整数序列,并提供了多个实际应用示例,如反向遍历列表、生成倒计时和计算递减等差数列的和。通过这些示例,读者可以更好地掌握`range`函数的使用方法。
73 5

热门文章

最新文章