day09-函数

最新推荐文章于 2024-07-27 17:39:19 发布

莫西莫西，python小精灵来喽

最新推荐文章于 2024-07-27 17:39:19 发布

阅读量167

点赞数

文章标签： python 开发语言

本文链接：https://blog.csdn.net/zhx13469781541/article/details/132124986

版权

作业

"""
定义一个函数，向函数内传入形参num, num1, num2，
如果num小于100，则计算num1 和 num2的积并打印；否则计算num1和num2的和，然后打印输出。
"""
def choose(num, num1, num2):
    if num < 100:
        print(num1 * num2)
    else:
        print(num1 + num2)

choose(101, 2, 3)

进程已结束,退出代码0

函数的作用域

# print('函数变量能起作用的范围')
x = 2
def func():
    global x
    # 函数中进行使用
    x = 3
    print(x,'x1')
    # return x
func()
print(x,'x2')
# 来猜一猜他的运行结果



# E(enclosing)：嵌套的父级函数的局部作用域
# def mytest1():
#     b = 6   # 局部变量  相对于mytest2是一个全局变量
#     def mytest2():
#         nonlocal b  # nonlocal 关键字用于在嵌套函数内部使用变量
#         b = 7  # 重新开辟了内存空间  注释掉直接打印b
#         print(b, id(b))
#     mytest2()
#     print(b, id(b))
#
# mytest1()

# x = max(1, 6)  # max为系统变量，它的作用域为python的所有模块
# print(x)
# y = 1  # y为全局变量，它的作用域为当前模块
# print(y)
print()
"""
print()内建的    适用与所有文件  
全局的    适用于当前文件    global
嵌套的父级    适用与当前文件的 函数相对全局变量   nonlocal  
局部的     当前文件函数的局部变量  

作用域越小的优先级越大  
"""

3 x1
3 x2

进程已结束,退出代码0

函数的参数

# def func(a, b, c):
#     print(a)
#     print(b)
#     print(c)
#
#
# func(11, 22, 33)
# 运行结果
# 11
# 22
# 33
# 上述案列中的函数的三个形参是按位置接收传入的实参，我们把这样的传参的形式叫做位置参数，

#
# def func(a, b, c):
#     print(a)
#     print(b)
#     print(c)
#
#
# func(11, c=99, b=33)


# 运行结果
# 11
# 33
# 99
# 调用函数函数的时候，实参通过参数名指定传给某个形参，这样的传参形式，我们把它叫做关键字参数
# 注意：传参的时候先写位置参数，再写关键字参数

# 调用函数的时候可以传可以不传，不传就用默认值
# def func(a, b, c=99):
#     print(a)
#     print(b)
#     print(c)
#
#
# func(11, 22, 33)
# print(1,2,3,4)
# print(1,2,3,4,sep='!')
# # print('-----------')
# func(55, 66)
# 注意：带有默认值的参数一定要位于参数列表的最后面。
# def func(a,b,c,*args):
#     print(a,b,c)
#     print(args)  # args 规定好的  约定俗成的
#
# func(33, 44, 55, 66, 77)
# func(*(33, 44, 55, 66, 77))

# 运行结果
# (33, 44, 55, 66, 77)
# (33, 44, 55, 66, 77)

# *args，args接收的是一个元祖；
# 调用的时候可以直接传入：func(33, 44, 55, 66, 77)，
# 也可以可以先组装list或tuple，再通过 * 拆包传入：func(*(33, 44, 55, 66, 77))；


def func(**kwargs):
    print(kwargs)


func(e=33, h=44, f=55, d=66, c=77)
func(**{'e': 33, 'h': 44, 'd': 66, 'c': 77})
# 运行结果
# {'e': 33, 'h': 44, 'f': 55, 'd': 66, 'c': 77}
# {'e': 33, 'h': 44, 'f': 55, 'd': 66, 'c': 77}

# **kwargs，kw接收的是一个字典；
# 关键字参数既可以直接传入：func(11,22,e=33,h=44,f=55,d=66,c=77)，
# 也可以先组装dict，再通过**拆包传入：func(**{'e':33,'h':44,'d':66,'c':77})。
# a, b, c = (1, 2, 3)
# print(a,b,c)

{'e': 33, 'h': 44, 'f': 55, 'd': 66, 'c': 77}
{'e': 33, 'h': 44, 'd': 66, 'c': 77}

进程已结束,退出代码0

函数的嵌套调用

# def func1():
#     print("这是外部函数")
#     def func2():
#         print("这是内部函数")
# func2()

# 1.在外函数内部调用内函数，即用函数名调用
# def func1():
#     print("这是外部函数")
#     def func2():
#         print("这是内部函数")
#     func2() #函数名调用内函数
# func1()


# 2.可以用return调用内函数
def func1():
    print("这是外部函数")
    def func2():
        print("这是内部函数")
    return func2
# func1()() ##执行func1()会返回func2然后再func2()
func2 = func1()
print(func2)
func2()

# func2() = func1()()
# m = func1()
# m()

这是外部函数
<function func1.<locals>.func2 at 0x000001D12FB6FA60>
这是内部函数

进程已结束,退出代码0

函数的返回值

# def function1(a,b):
#     result = a +b
#     print(result)
#     return result   # 函数调用处
#
#
#
# print(function1(11,22))   # None
#
#
# print(len('1234'))


# 函数的多个返回值
def my_test2():
    a, b, c = (1, 2, 3)
    # return a  # 当函数中有多个return时，不会报错，但是只会执行第一个
    # return b  # 后面的代码为什么不会被执行  return返回到函数调用处了
    # return c
    return a, b, c  # 写在一起 但返回的类型为元组


values = my_test2()
print(values)
print(type(values))

(1, 2, 3)
<class 'tuple'>

进程已结束,退出代码0

递归

# 一个函数返回值（return）为另外一个函数（返回为自己，则为递归）


# 用正向递推的方式计算阶乘
# def factorial(n):
#     fact = 1
#     for i in range(1, n + 1):
#         fact *= i
#     return fact
#
# print(factorial(5))

"""递归是一种思想 不是说所有的解题都要用到  有时候用循环挺好的
能用递推正向的 实现的 递归 逆向的 都可以实现

"""
# 递归实现阶乘  5! = 5*4*3*2*1
def asd(n):
    if n == 1:
        return 1   # 出口
    else:
        return n * asd(n - 1)


result = asd(5)
print(result)
"""
总结果: factorial(5)
第一次调用     factorial(5) =  5 * factorial(4)
第二次调用     factorial(4) =  4 * factorial(3)
第三次调用     factorial(3) =  3 * factorial(2)
第四次调用     factorial(2) =  2 * factorial(1)
第五次调用     factorial(1) =  1 
表达式:  5 * 4 * 3 * 2 *  1 


factorial(5)                        # 第 1 次调用使用 5
5 * factorial(4)                    # 第 2 次调用使用 4
5 * (4 * factorial(3))              # 第 3 次调用使用 3
5 * (4 * (3 * factorial(2)))        # 第 4 次调用使用 2
5 * (4 * (3 * (2 * factorial(1))))  # 第 5 次调用使用 1 
5 * (4 * (3 * (2 * 1)))             # 从第 5 次调用返回
5 * (4 * (3 * 2))                   # 从第 4 次调用返回
5 * (4 * 6)                         # 从第 3 次调用返回
5 * 24                              # 从第 2 次调用返回
120                                 # 从第 1 次调用返回


"""




# def asd():
#     print(1)
#     asd()
#     # RecursionError: maximum recursion depth exceeded while calling a Python object
#
# asd()

120

进程已结束,退出代码0

高阶函数

print()
"""
一个函数的函数名
作为参数传给另外一个函数
"""
def func():
    print("定义一个普通函数")

def high_level(func):
    print("定义一个高阶函数")
    # 在函数内部，通过传入的函数参数调用
    func()

high_level(func)

"""
一个函数返回值（return）为另外一个函数
（返回为自己，则为递归）

"""
# def func():
#     print("定义一个普通函数")
#
#
# def high_level(func):
#     print("定义一个高阶函数")
#     return func
#     #  return func() 这个是直接返回函数调用，递归函数就是如此
# res = high_level(func)
# # 高阶函数返回函数之后在调用func函数
# res()

# lis = [1, 2, 3, 4, 5]
# # 返回他的平方
# def square(x):
#     return x ** 2
#
# print(map(square,lis ), type(map(square, lis)))
#
# res = map(square, lis)
# for i in res:
#     print(i)
# print(list(map(square, lis)))

li = list('123456789')
print(li)
res = map(int, li)
print(list(res))


# 在一个list中，删掉偶数，只保留奇数
# def is_odd(n):
#     return n % 2 == 1
#
# print(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# print(list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])))


# from functools import reduce
# def fn(x, y):
#     return x * y
#
# res = reduce(fn, [1, 3, 5, 7, 9])
# print(res)

定义一个高阶函数
定义一个普通函数
['1', '2', '3', '4', '5', '6', '7', '8', '9']
[1, 2, 3, 4, 5, 6, 7, 8, 9]

进程已结束,退出代码0