Python基础day04函数(下)

纯洁的代码
96 阅读13分钟
函数返回值
(二)


在
python中我们怎样返回多个值？




<1> 多个return?


def
create_nums
()
:


print(
"---1---"
)


return
1
# 函数中下面的代码不会被执行，因为return除了能够将数据返回之外，还有一个隐藏的功能：结束函数


print(
"---2---"
)


return
2


print(
"---3---"
)



总结
1：


·
一个函数中可以有多个
return语句，但是只要有一个return语句被执行到，那么这个函数就会结束了，因此后面的return没有什么用处


[size=10.0000pt]·

如果程序设计为如下，是可以的因为不同的场景下执行不同的
return


[size=10.0000pt]·

def
create_nums
(num)
:


print(
"---1---"
)


if
num ==
100
:


print(
"---2---"
)


return
num+
1
# 函数中下面的代码不会被执行，因为return除了能够将数据返回之外，还有一个隐藏的功能：结束函数


else
:


print(
"---3---"
)


return
num+
2


print(
"---4---"
)



result1 = create_nums(
100
)


print(result1)
# 打印101


result2 = create_nums(
200
)


print(result2)
# 打印202


[size=10.0000pt]·



<2> 一个函数返回多个数据的方式




def
divid
(a, b)
:


shang = a//b


yushu = a%b


return
shang, yushu
#默认是元组



result = divid(
5
,
2
)


print(result)
# 输出(2, 1)




总结
2：


·
return后面可以是元组，列表、字典等，只要是能够存储多个数据的类型，就可以一次性返回多个数据


def
function
()
:


# return [1, 2, 3]


# return (1, 2, 3)


return
{
"num1"
:
1
,
"num2"
:
2
,
"num3"
:
3
}


[size=10.0000pt]·
[size=10.0000pt]·

如果
return后面有多个数据，那么默认是元组


[size=10.0000pt]·

In [
1
]: a =
1
,
2


In [
2
]: a


Out[
2
]: (
1
,
2
)



In [
3
]:


In [
3
]: b = (
1
,
2
)


In [
4
]: b


Out[
4
]: (
1
,
2
)



In [
5
]:


[size=10.0000pt]·


函数参数
(二)




<1>. 缺省参数




调用函数时，缺省参数的值如果没有传入，则取默认值。


下例会打印默认的
age，如果age没有被传入：


def
printinfo
(name, age=35)
:


# 打印任何传入的字符串


print(
"name: %s"
% name)


print(
"age %d"
% age)


# 调用printinfo函数


printinfo(name=
"miki"
)
# 在函数执行过程中 age去默认值35


printinfo(age=
9
,name=
"miki"
)




以上实例输出结果：


name: miki


age:
35


name: miki


age:
9




总结
1：


·
在形参中默认有值的参数，称之为缺省参数


·
注意：带有默认值的参数一定要位于参数列表的最后面


>>>
def
printinfo
(name, age=35, sex)
:


...
print
name


...


File
"<stdin>"
, line
1


SyntaxError: non-default argument follows default argument


[size=10.0000pt]·



<2>. 不定长参数


有时可能需要一个函数能处理比当初声明时更多的参数
, 这些参数叫做不定长参数，声明时不会命名。




基本语法如下：


def
functionname
([formal_args,] *args, **kwargs)
:


"""函数_文档字符串"""


function_suite


return
[expression]




注意：


·
加了星号（
*）的变量args会存放所有未命名的变量参数，args为元组


·
而加
**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典.


>>>
def
fun
(a, b, *args, **kwargs)
:


...
"""可变参数演示示例"""


...
print(
"a =%d"
% a)


...
print(
"b =%d"
% b)


...
print(
"args:"
)


...
print(args)


...
print(
"kwargs: "
)


...
for
key, value
in
kwargs.items():


...
print(
"key=%s"
% value)


...


>>>
fun(
1
,
2
,
3
,
4
,
5
, m=
6
, n=
7
, p=
8
)
# 注意传递的参数对应


a =
1


b =
2


args:


(
3
,
4
,
5
)


kwargs:


p =
8


m =
6


n =
7


>>>


>>>


>>>


>>>
c = (
3
,
4
,
5
)


>>>
d = {
"m"
:
6
,
"n"
:
7
,
"p"
:
8
}


>>>
fun(
1
,
2
, *c, **d)
# 注意元组与字典的传参方式


a =
1


b =
2


args:


(
3
,
4
,
5
)


kwargs:


p =
8


m =
6


n =
7


>>>


>>>


>>>


>>>
fun(
1
,
2
, c, d)
# 注意不加星号与上面的区别


a =
1


b =
2


args:


((
3
,
4
,
5
), {
'p'
:
8
,
'm'
:
6
,
'n'
:
7
})


kwargs:


>>>


>>>




<3>. 缺省参数在*args后面




def
sum_nums_3
(a, *args, b=22, c=33, **kwargs)
:


print(a)


print(b)


print(c)


print(args)


print(kwargs)



sum_nums_3(
100
,
200
,
300
,
400
,
500
,
600
,
700
, b=
1
, c=
2
, mm=
800
, nn=
900
)




说明：


·
如果很多个值都是不定长参数，那么这种情况下，可以将缺省参数放到
*args的后面， 但如果有**kwargs的话，**kwargs必须是最后的


拆包、交换变量的值



<1> 对返回的数据直接拆包


def
get_my_info
()
:


high =
178


weight =
100


age =
18


return
high, weight, age



# result = get_my_info()# print(result)



my_high, my_weight, my_age = get_my_info()


print(my_high)


print(my_weight)


print(my_age)



总结：


·
拆包时要注意，需要拆的数据的个数要与变量的个数相同，否则程序会异常


[size=10.0000pt]·

除了对元组拆包之外，还可以对列表、字典等拆包



In [
17
]: a, b = (
11
,
22
)


In [
18
]: a


Out[
18
]:
11


In [
19
]: b


Out[
19
]:
22



In [
20
]: a, b = [
11
,
22
]


In [
21
]: a


Out[
21
]:
11


In [
22
]: b


Out[
22
]:
22



In [
23
]: a, b = {
"m"
:
11
,
"n"
:
22
}
# 取出来的是key，而不是键值对


In [
24
]: a


Out[
24
]:
'm'


In [
25
]: b


Out[
25
]:
'n'





<2> 交换2个变量的值




# 第1种方式# a = 4# b = 5# c = 0## c = a# a = b# b = c## print(a)# print(b)


# 第2种方式# a = 4# b = 5# a = a+b # a=9, b=5# b = a-b # a=9, b=4# a = a-b # a=5, b=4# print(a)# print(b)


# 第3种方式


a, b =
4
,
5


a, b = b, a



print(a)


print(b)
[size=11.3333px]



引用
(一)



想一想


>>>
a =
1


>>>
b = a


>>>
b


1


>>>
a =
2


>>>
a


2


请问此时
b的值为多少？


>>>
a = [
1
,
2
]


>>>
b = a


>>>
b


[
1
,
2
]


>>>
a.append(
3
)


>>>
a


[
1
,
2
,
3
]


请问此时
b的值又是多少？


引用


在
python中，值是靠引用来传递来的。


我们可以用
id()来判断两个变量是否为同一个值的引用。
我们可以将id值理解为那块内存的地址标示。


>>>
a =
1


>>>
b = a


>>>
id(a)


13033816


>>>
id(b)
# 注意两个变量的id值相同


13033816


>>>
a =
2


>>>
id(a)
# 注意a的id值已经变了


13033792


>>>
id(b)
# b的id值依旧


13033816


>>>
a = [
1
,
2
]


>>>
b = a


>>>
id(a)


139935018544808


>>>
id(b)


139935018544808


>>>
a.append(
3
)


>>>
a


[
1
,
2
,
3
]


>>>
id(a)


139935018544808


>>>
id(b)
# 注意a与b始终指向同一个地址


139935018544808



总结：


·
之前为了更好的理解变量，咱们可以把
a=100
理解为变量
a中存放了100，事实上变量a存储是100的引用（可理解为在内存中的一个编号）
[size=21.3333px]


可变、不可变类型


总结


·
所谓可变类型与不可变类型是指：数据能够直接进行修改，如果能直接修改那么就是可变，否则是不可变


·
可变类型有：
列表、字典、集合


·
不可变类型有：
数字、字符串、元组
[size=21.3333px]


引用
(二)


引用当做实参


·
可变类型与不可变类型的变量分别作为函数参数时，会有什么不同吗？


·
Python有没有类似C语言中的指针传参呢？




def
test1
(b)
:
# 变量b一定是一个局部变量，就看它指向的是谁？可变还是不可变


b += b
# += 是直接对b指向的空间进行修改,而不是让b指向一个新的


# b = b+b # xx = xx+yyy 先把=号右边的结果计算出来,然后让b指向这个新的地方,不管原来b指向谁


# 现在b一定指向这个新的地方


# a = [11, 22]


a =
100


test1(a)


print(a)




总结：


·
Python中函数参数是引用传递（注意不是值传递）


·
对于不可变类型，因变量不能修改，所以运算不会影响到变量自身


·
而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量
[size=21.3333px]




函数应用：学生管理系统

[Python]
纯文本查看
复制代码
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092
093
094
095
096
097
098
099
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
import time
import os
# 定一个列表，用来存储所有的学生信息(每个学生是一个字典)
info_list = []
def print_menu():
print("---------------------------")
print(" 学生管理系统 V1.0")
print(" 1:添加学生")
print(" 2:删除学生")
print(" 3:修改学生")
print(" 4:查询学生")
print(" 5:显示所有学生")
print(" 6:退出系统")
print("---------------------------")
def add_new_info():
"""添加学生信息"""
global info_list
new_name = input("请输入姓名:")
new_tel = input("请输入手机号:")
new_qq = input("请输入QQ:")
for temp_info in info_list:
if temp_info['name'] == new_name:
print("此用户名已经被占用,请重新输入")
return # 如果一个函数只有return就相当于让函数结束，没有返回值
# 定义一个字典，用来存储用户的学生信息(这是一个字典)
info = {}
# 向字典中添加数据
info["name"] = new_name
info["tel"] = new_tel
info["qq"] = new_qq
# 向列表中添加这个字典
info_list.append(info)
def del_info():
"""删除学生信息"""
global info_list
del_num = int(input("请输入要删除的序号:"))
if 0 <= del_num < len(info_list):
del_flag = input("你确定要删除么?yes or no")
if del_flag == "yes":
del info_list[del_num]
else:
print("输入序号有误,请重新输入")
def modify_info():
"""修改学生信息"""
global info_list
modify_num = int(input("请输入要修改的序号:"))
if 0 <= modify_num < len(info_list):
print("你要修改的信息是:")
print("name:%s, tel:%s, QQ:%s" % (info_list[modify_num]['name'],
info_list[modify_num]['tel'],info_list[modify_num]['qq']))
info_list[modify_num]['name'] = input("请输入新的姓名:")
info_list[modify_num]['tel'] = input("请输入新的手机号:")
info_list[modify_num]['qq'] = input("请输入新QQ:")
else:
print("输入序号有误,请重新输入")
def search_info():
"""查询学生信息"""
search_name = input("请输入要查询的学生姓名:")
for temp_info in info_list:
if temp_info['name'] == search_name:
print("查询到的信息如下:")
print("name:%s, tel:%s, QQ:%s" % (temp_info['name'],
temp_info['tel'], temp_info['qq']))
break
else:
print("没有您要找的信息....")
def print_all_info():
"""遍历学生信息"""
print("序号\t姓名\t\t手机号\t\tQQ")
i = 0
for temp in info_list:
# temp是一个字典
print("%d\t%s\t\t%s\t\t%s" % (i, temp['name'], temp['tel'], temp['qq']))
i += 1
def main():
"""用来控制整个流程"""
while True:
# 1. 打印功能
print_menu()
# 2. 获取用户的选择
num = input("请输入要进行的操作(数字)")
# 3. 根据用户选择,做相应的事情
if num == "1":
# 添加学生
add_new_info()
elif num == "2":
# 删除学生
del_info()
elif num == "3":
# 修改学生
modify_info()
elif num == "4":
# 查询学生
search_info()
elif num == "5":
# 遍历所有的信息
print_all_info()
elif num == "6":
# 退出系统
exit_flag = input("亲,你确定要退出么?~~~~(>_<)~~~~(yes or no) ")
if exit_flag == "yes":
break
else:
print("输入有误,请重新输入......")
input("\n\n\n按回车键继续....")
os.system("clear") # 调用Linux命令clear完成清屏
# 程序的开始
main()



递归函数




<1>什么是递归函数
通过前面的学习知道一个函数可以调用其他函数。
如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。


<2>递归函数的作用
举个例子，我们来计算阶乘
n! = 1 * 2 * 3 * ... * n
解决办法
1:


看阶乘的规律
1! = 1
2! = 2 × 1 = 2 × 1!
3! = 3 × 2 × 1 = 3 × 2!
4! = 4 × 3 × 2 × 1 = 4 × 3!
...
n! = n × (n-1)!
解决办法
2:


原理



匿名函数


用
lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。


lambda函数的语法只包含一个语句，如下：


lambda
[arg1 [,arg2,.....argn]]:expression




如下实例：


sum =
lambda
arg1, arg2: arg1 + arg2



#调用sum函数


print
"Value of total : "
, sum(
10
,
20
)


print
"Value of total : "
, sum(
20
,
20
)




以上实例输出结果：


Value of total :
30


Value of total :
40




Lambda函数能接收任何数量的参数但只能返回一个表达式的值


匿名函数不能直接调用
print，因为lambda需要一个表达式



应用场合


函数作为参数传递



1.
自己定义函数


>>>
def
fun
(a, b, opt)
:
...
print
"a ="
, a
...
print
"b ="
, b
...
print
"result ="
, opt(a, b)


...
>>>
fun(
1
,
2
,
lambda
x,y:x+y)


a =
1


b =
2


result =
3


2.
作为内置函数的参数




想一想，下面的数据如何指定按
age或name排序？


stus = [


{
"name"
:
"zhangsan"
,
"age"
:
18
},


{
"name"
:
"lisi"
,
"age"
:
19
},


{
"name"
:
"wangwu"
,
"age"
:
17
}


]




按
name排序：


>>>
stus.sort(key =
lambda
x:x[
'name'
])


>>>
stus


[{
'age'
:
19
,
'name'
:
'lisi'
}, {
'age'
:
17
,
'name'
:
'wangwu'
}, {
'age'
:
18
,
'name'
:
'zhangsan'
}]




按
age排序：


>>>
stus.sort(key =
lambda
x:x[
'age'
])


>>>
stus


[{
'age'
:
17
,
'name'
:
'wangwu'
}, {
'age'
:
18
,
'name'
:
'zhangsan'
}, {
'age'
:
19
,
'name'
:
'lisi'
}]




函数使用注意事项


1. 自定义函数


<1>无参数、无返回值


def
函数名
()
:


语句


<2> 无参数、有返回值


def
函数名
()
:


语句


return
需要返回的数值




注意
:


·
一个函数到底有没有返回值，就看有没有
return，因为只有return才可以返回数据


·
在开发中往往根据需求来设计函数需不需要返回值


·
函数中，可以有多个
return语句，但是只要执行到一个return语句，那么就意味着这个函数的调用完成




<3>有参数、无返回值


def 函数名(形参列表):


语句




注意：


·
在调用函数时，如果需要把一些数据一起传递过去，被调用函数就需要用参数来接收


·
参数列表中变量的个数根据实际传递的数据的多少来确定




<4>有参数、有返回值


def 函数名(形参列表):


语句


return 需要返回的数值




<5>函数名不能重复





2. 调用函数


<1>调用的方式为：


函数名
([实参列表])




<2>调用时，到底写不写 实参


·
如果调用的函数
在定义时有形参，那么在调用的时候就应该传递参数


<3>调用时，实参的个数和先后顺序应该和定义函数中要求的一致


<4>如果调用的函数有返回值，那么就可以用一个变量来进行保存这个值




3. 作用域




<1>在一个函数中定义的变量，只能在本函数中用(局部变量)



<2>在函数外定义的变量，可以在所有的函数中使用(全局变量)
更多免费技术资料可关注：annalin1203


avatar
文章
阅读
粉丝