pythonpython基础

04-函数

Catalogue
  1. 1. 一.01_函数的定义和调用
  2. 2. 二.02_函数的形参和实参
  3. 3. 三.03_函数的形参和实参_补充
  4. 4. 四.04_函数的返回值
  5. 5. 五.05_函数的类型
  6. 6. 六.06_函数的嵌套
  7. 7. 七.07_函数的参数
  8. 8. 八.08_函数的参数2
  9. 9. 九.09_关键字参数3
  10. 10. 十.10_函数的参数4
  11. 11. 十一.11_票务管理系统
  12. 12. 十一.12_函数文档
  13. 13. 十三.13_票务管理系统_函数版
  14. 14. 十四.14_回调函数
  15. 15. 十五.15_lambda表达式
  16. 16. 十六.16_函数递归
  17. 17. 十七.17_高阶函数
  18. 18. 十八.18_高阶函数2
  19. 19. 十九.19_闭包
    1. 19.1. 参考资料

一.01_函数的定义和调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
"""
函数的定义：
    def 函数名([参数1,参数2,...,参数n]):
        函数体
        [return 值]
"""

def talk():
    print("你好，兄弟")

talk()
talk()
print(type(talk))

#内置模块
import builtins
#dir 查看模块中有哪些方法和函数
print(dir(builtins))

二.02_函数的形参和实参

1
2
3
4
5
6
7
8
9
10
11
"""
形参(变量): 在定义函数的时候的参数列表，在小括号中
实参(对象)：在函数调用的时候传入的一个实际的对象，会赋值给形参
"""

#这里的name,就是形参
def talk(name,age):
    print("{},你好，兄弟，是不是{}岁了".format(name,age))

talk("jack",21)
talk("lucy",18)

三.03_函数的形参和实参_补充

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
"""
"""

def fn(x,y):
    x[0] = 1
    y[0] = 5
    print("x:{}, y:{}".format(x,y))

a = [100]
b = [200]

#如果传递的是可变类型的数据，可能会对外面的数据值发生改变
fn(a,b)

print("a:{}, b:{}".format(a,b))

四.04_函数的返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
"""
"""

def fn():
    print("执行函数")
    #元组的装包功能
    return 100,200,300

#定义一个ret变量接收fn函数的返回值
#没有return,则返回None, 如果有return，直接返回后面的值
#如果返回多个值，则会包装成一个元组返回

#ret = fn()
#print("函数返回结果：",ret)

x,y,z = fn()
print("函数返回结果:",x,y,z)

五.05_函数的类型

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
"""
函数类型：
1，无参数无返回值
2，无参数有返回值
3，有参数无返回值
4，有参数有返回值
"""

#无参数无返回值
def talk():
    print("talk")

talk()

#无参数有返回值
def get_time():
    return "20200806"
    
ret = get_time()
print("时间:",ret)

#有参数无返回值
def insert(record):
    print("插入数据{}成功".format(record))

insert(123)

#有参数有返回值
def get_sum(x,y):
    print(x,y)
    return x+y
ret = get_sum(10,11)
print("结果:",ret)

六.06_函数的嵌套

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 fun_a():
    print("执行函数a")

def fun_b():
    print("执行函数b")
    fun_a()
    print("函数b执行完毕")

fun_b()
"""

#函数的嵌套定义
def fun_a():
    print("开始执行函数a")
    
    def fun_b():
        print("执行函数b")
    
    fun_b()
    print("函数a执行完毕")

fun_a()

七.07_函数的参数

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
"""
"""
def fun_a(x,y):
    print("fun_a:",x,y)

#关键字参数，在函数调用的时候，使用name=value
fun_a(y=1,x=2)

def fun_b(x,y,z):
    print("fun_b:",x,y,z)
    

fun_b(1,2,3)
#对于关键字参数和位置可以结合使用
#位置参数必须在关键字参数前面
fun_b(1,z=100,y=300)    #显示位置参数，再是关键字参数

#这是错误的，位置参数必须在关键字参数前面
#fun_b(z=3,2,x=1)

print("="*50)
def fun_c(x,y=10,z=20):
    print("fun_c:",x,y,z)

fun_c(1)
fun_c(1,2)
fun_c(1,2,3)
#需要： 如果y使用默认值，其他餐宿x=4, z=6
fun_c(4,z=6)

print(123,end="\t")
print(456,end="\t")
print(help(print))

八.08_函数的参数2

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
"""
"""

#不定长参数
# *args代表可以接受多个非关键字参数
# 如果在 *args 前面的参数，可以通过位置参数来赋值，
# 在 *args后面的参数，可以通过关键字参数赋值
def sum(x,*args,y):
    print("args:",args)
    print("x:",x)
    print("y:",y)

sum(1,2,4,y=3)

print("*"*50)

#必须使用关键字参数传递
def fun_b(*args, x,y,z):
    print("x:{},y:{},z:{}".format(x,y,z))

fun_b(x = 1, y = 2,z = 3)

#必须使用关键字参数传递，而且只能是3个参数
# 当只使用*符号，代表后面的必须是关键字参数，而且参数个数必须相等
def fun_c(*,x,y,z):
    print("x:{},y:{},z:{}".format(x,y,z))
fun_c(x = 1,y=2,z=3)

九.09_关键字参数3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
"""
"""

#不定长参数
def fun_a(*args,x,y,z):
    print("args:",args)
    print("x:{},y:{},z:{}".format(x,y,z))

fun_a(88,x = 1,y=2,z=3)

print("*"*50)

#不定长关键参数
#如果需要接收多个关键字参数，需要使用**keywords, 必须放到最后一个参数
def fun_b(*args,x,y,z,**keywords):
    print("args:",args)
    print("keywords:",keywords)
    print("x:{},y:{},z:{}".format(x,y,z))

fun_b(88, x = 1,y = 2,z = 3, key=99,num=1000)

十.10_函数的参数4

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
"""
"""
def fun_a(x,y,z):
    print("x:{},y:{},z:{}".format(x,y,z))

fun_a(1,2,3)
#a 是一个元组
a = (8,9,10)
#在调用的时候，通过*对元组进行解包操作
fun_a(*a)

print("*"*50)

#必须是关键字参数
def fun_b(*,x,y,z):
    print("x:{},y:{},z:{}".format(x,y,z))
    
fun_b(x = 1,y = 2, z= 3)

d = {"x":40,"y":50,"z":60}
#对字典进行拆包为关键字参数
fun_b(**d)

#总结：
# *args 在函数定义的时候，不定长的非关键字参数
# **keywords 在函数定义的时候，不定长的关键字参数
# *a  在函数调用的时候，把元组拆包为对应的参数
# **d 在函数调用的时候，把字典拆包为对应的参数

十一.11_票务管理系统

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
print("*"*50)
print("1 查询所有车票")
print("2 根据开始站点,目的站点,时间来查询")
print("3 购买车票")
print("4 退票")
print("5 退出系统")
print("*"*50)

tickets = [
    {"开始站点":"广州","目的站点":"北京","日期":"20200101","票价":500,"数量":100},
    {"开始站点":"广州","目的站点":"武汉","日期":"20200101","票价":300,"数量":100},
    {"开始站点":"北京","目的站点":"青岛","日期":"20200101","票价":300,"数量":100},
    {"开始站点":"郑州","目的站点":"北京","日期":"20200101","票价":300,"数量":100},
    {"开始站点":"北京","目的站点":"丽江","日期":"20200101","票价":600,"数量":100},
]

while True:
    model = input("请输入你选择的操作序号:")
    if model == "1":
        for ticket in tickets:
            print(ticket)
    elif model == "2":
        start = input("请输入开始站点:")
        end = input("请输入目的站点:")
        date = input("请输入日期:")
        for ticket in tickets:
            if ticket["开始站点"] == start and ticket["目的站点"] == end and ticket["日期"] == date :
                print("票务信息:",ticket)
                break
        else:
            print("没有找到你需要的车票信息")
    elif model == "3":
        start = input("请输入开始站点:")
        end = input("请输入目的站点:")
        date = input("请输入日期:")
        for ticket in tickets :
            if ticket["开始站点"] == start and ticket["目的站点"] == end  and ticket["日期"] == date :
                if ticket["数量"] > 0 :
                    ticket["数量"] -= 1
                    print("购票成功")
                else:
                    print("余票不足")
                break
        else:
            print("没有找到对应的票务信息")
    elif model == "4":
        start = input("请输入开始站点:")
        end = input("请输入目的站点:")
        date = input("请输入日期:")
        price = input("请输入票价:")
        for ticket in tickets:
            if ticket["开始站点"] == start and ticket["目的站点"] == end and ticket["日期"] == date :
                ticket["数量"] += 1
                break
        else:
            tickets.append({"开始站点":start,"目的站点":end,"日期":date,"票价":price,"数量":1})
            
        print("退票成功")
    elif model == "5":
        break
    else:
        print("输入序号有误，请重新输入")

十一.12_函数文档

1
2
3
4
5
6
7
8
9
10
def fun_a(x,y,z):
    """ 这是测试函数 
        x:int
        y:int
        z:int
    """
    print(x,y,z)

#help 查看帮助信息
print(help(fun_a))

十三.13_票务管理系统_函数版

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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
"""
函数版
"""

#打印菜单
def print_menu():
    print("*"*50)
    print("1 查询所有车票")
    print("2 根据开始站点,目的站点,时间来查询")
    print("3 购买车票")
    print("4 退票")
    print("5 退出系统")
    print("*"*50)

tickets = [
    {"开始站点":"广州","目的站点":"北京","日期":"20200101","票价":500,"数量":100},
    {"开始站点":"广州","目的站点":"武汉","日期":"20200101","票价":300,"数量":100},
    {"开始站点":"北京","目的站点":"青岛","日期":"20200101","票价":300,"数量":100},
    {"开始站点":"郑州","目的站点":"北京","日期":"20200101","票价":300,"数量":100},
    {"开始站点":"北京","目的站点":"丽江","日期":"20200101","票价":600,"数量":100},
]

#查询所有车票
def query_all():
    for ticket in tickets:
        print(ticket)
        
#根据条件查询
def query_by_params(start_tmp,end_tmp,date):
     for ticket in tickets:
        if ticket["开始站点"] == start_tmp and ticket["目的站点"] == end_tmp and ticket["日期"] == date :
            return ticket
     return None;

#购买车票
def buy_ticket(start_tmp,end_tmp,date):
    ticket = query_by_params(start_tmp,end_tmp,date)
    if ticket == None:
        print("没有找到对应的票务信息")
    else:
        if ticket["数量"] > 0 :
            ticket["数量"] -= 1
            print("购票成功")
        else:
            print("余票不足")

#退票
def return_ticket(start_tmp,end_tmp,date,price):
    ticket = query_by_params(start_tmp,end_tmp,date)
    if ticket == None:
        tickets.append({"开始站点":start,"目的站点":end,"日期":date,"票价":price,"数量":1})
    else:
        ticket["数量"] += 1
    print("退票成功")

#打印菜单
print_menu()

while True:
    model = input("请输入你选择的操作序号:")
    if model == "1":
        query_all()
    elif model == "2":
        start = input("请输入开始站点:")
        end = input("请输入目的站点:")
        date = input("请输入日期:")
        ticket = query_by_params(start,end,date)
        if ticket == None:
            print("没有找到你需要的车票信息")
        else:
            print("票务信息:",ticket)
    elif model == "3":
        start = input("请输入开始站点:")
        end = input("请输入目的站点:")
        date = input("请输入日期:")
        buy_ticket(start,end,date)
    elif model == "4":
        start = input("请输入开始站点:")
        end = input("请输入目的站点:")
        date = input("请输入日期:")
        price = input("请输入票价:")
        return_ticket(start,end,date,price)
    elif model == "5":
        break
    else:
        print("输入序号有误，请重新输入")

十四.14_回调函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def send_msg():
    """发送消息"""
    print("亲爱的，我到家了")

#回调函数，传函数名称即可
def go_home(callback):
    """回家
        callback:function
    """
    print("打出租车回家了")
    print("到家了")
    callback()

def eat():
    print("肚子饿了，吃点方便面")

#go_home(eat)
#go_home(send_msg)

#lambda: 匿名函数
go_home(lambda: print("再和别人去看电影"))

十五.15_lambda表达式

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
#用于计算两个数字的和
def sum(x,y):
    """用于计算两个数字之和"""
    return x+y

#通过 lambda表达式 可以简化代码
sum2 = lambda x,y: x+y
print(sum(1,2))
print(sum2(3,4))

def go_home(callback):
    print("开始执行")
    callback()
    print("完成执行")

go_home(lambda: print("lambda函数"))

print("*"*50)

def max(x,y):
    """ 返回x,y中最大数 """
    """
    if x >= y:
        return x
    else:
        return y
    """
    #三元运算符
    # x if x>= y   表示：默认返回x,是在x>=y的情况返回的
    # else y  表示：前边的x>=y不成立，返回的是y值
    return x if x >=y else y
    
#lambda表达式
max2 = lambda x,y: x if x>=y else y
print(max(1,4))
print(max(1,4))

print("*"*50)

def max3(x,y,z):
    """ 返回x,y,z中的最大数 """
    """
    #普通方式
    if x>= y and x>=z:
        return x
    elif y>=x and y>=z:
        return y
    else:
        return z
    """
    #使用lambda表达式, 在不够清晰的时候，不建议使用lambda表达式
    return x if x>=y and x>=z else y if y>=x and y>=z else z
print(max3(1,3,5))

print("*"*50)
def max4(x,y,z):
    """ 返回x,y,z中的最大数 """
    #普通方式
    print("max4：123")
    print("max4: 456")
    if x>= y and x>=z:
        return x
    elif y>=x and y>=z:
        return y
    else:
        return z

#在表达式中执行多个语句时，需要使用逻辑运算符 or 或者 and
max5 = lambda x,y,z: print("max5: 123") or print("max5: 456") or (x if x>=y and x>=z else y if y>=x and y>=z else z)
print(max4(10,3,5))
print(max5(10,3,5))

十六.16_函数递归

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#需求：计算 1 - N之间的整数加和

#普通的循环
def sum(x):
    value = 0
    for item in range(1,x+1):
        value += item
    return value

print(sum(10))

#递归
def sum2(x):
    value = 0
    if x > 1:
        value = x + sum2(x-1)
    else:
        value = 1
    return value
    
print(sum2(10))

十七.17_高阶函数

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
"""
高阶函数定义：（满足下边两个条件之一）
1，接受一个或者多个函数作为参数
2，输出一个函数
"""

"""
#高阶函数
def fun_a(callback):
    callback()
    print("fun_a")

def fun_b():
    print("fun_b")

fun_a(fun_b)

def fun_c():
    print("fun_c")
    return fun_b

ret = fun_c()
print(ret)
ret()
"""

#需求：将列表[1,2,3,4,5]中的每个元素都加上10，生成一个新的列表

"""
#for循环方式
list_a = [1,2,3,4,5]
list_b = []
for item in list_a:
    list_b.append(item+10)
print(list_b)
"""

#map方式
#map 是一个映射，接收两个参数，第一个参数为一个函数，第二个参数为序列（列表，元组）
# map的返回值是一个可迭代的对象，使用list(ret)转换为序列
list_a = [1,2,3,4,5]
fn = lambda x: x+10
ret = map(fn,list_a)
print(ret)
print(list(ret))

print("需求二:")
print("*"*50)
#将两个列表中的索引对应的元素加起来，形成一个新的列表
list_x = [11,12,13,14,15]
list_y = [21,22,23,24,25]
ret = map(lambda x,y:x+y, list_x,list_y)
print(list(ret))

十八.18_高阶函数2

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
#reduce(fn,序列) 用于做累计运算
#fn: 函数，有2个参数，返回一个值
#整体返回一个需要累计运算的值

#需求：计算数字列表中，所有的数字乘积

from functools import reduce
list_a = [2,4,6,8,10]
ret = reduce(lambda x,y:x*y, list_a)
print(ret)

#需求：给定一个list集合，找出所有大于80的数据

#filter(fn,序列) ：用来做过滤
#fn: 接受一个参数，返回一个布尔值
list_b = [112,134,34,60,100]
ret = filter(lambda x: x>=80, list_b)
print(ret)
print(list(ret))

"""
总结：
高阶函数有:
map, reduce, filter, sorted
"""

十九.19_闭包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#闭包定义：
#1，函数A 中定义函数B
#2，函数A 返回 函数B
#3，函数B 中访问了 函数A中的变量

#需求：提供一个函数，用于生成一个自动增长的数字1,2,3,4

def get_id():
    num = 0
    def gen_id():
        #非全局变量
        nonlocal num
        num += 1
        return num
    return gen_id
    
callback = get_id()
print(callback())
print(callback())
print(callback())
print(callback())

参考资料