Python基础第10讲 - 函数

Python基础第10讲 - 函数

一、函数返回值 ：返回值就是函数执行返回的结果

1.1求任意数的和

```handlebars
def s(*nums):

    # 定义一个变量保存结果
    result = 0

    # 遍历元组，并将元组当中的元素进行累加
    for n in nums:

        result += n

    print(result)
s(1,2,3)
# 结果： 6

用return来指定函数的返回值
我们可以直接使用函数的返回值，可以通过变量来接收函数的返回值
return后面可以跟任意对象，甚至是一个函数

def fn():
    return 100
    return 'python'
    return [1,2,3]
    return {'a':'b'}
r = fn()        # 这个函数执行的结果就是返回值的结果
print(r)        # 100

def fn():
    def fn2():
        print("hello")
    return fn2
r = fn()
print(r)  # <function fn.<locals>.fn2 at 0x017750C0>

如果仅仅写一个return或者不写return则相当于return none

def fn2():

    # return
    a = 10
r = fn2()

print(r)    # None

在函数中，return后面的代码不会执行，return一旦执行函数自动结束

def fn3():

    print('python')
    return
    print('java')
r = fn3()
print(r)
# 结果：   python
#         None

return可以用结束函数

def fn4():

    for i in range(5):
        if i == 3:
            # break # break退出当前循环
            # continue # continue跳过本次循环
            return # return可以用结束函数
        print(i)
    print('循环执行完毕')


fn4()
# 结果： 0
#       1
#       2

fn5和fn5()的区别

1. fn5是函数对象 打印fn5就是在打印函数对象

2. fn5()是在调用函数 打印fn5()实际上是在打印fn5()函数的返回值

def fn5():

    return 1

# fn5是函数对象  打印fn5就是在打印函数对象
print(fn5)          #   <function fn5 at 0x03405228>

# fn5()是在调用函数 打印fn5()实际上是在打印fn5()函数的返回值
print(fn5())        #  1

二、文档字符串

help()可以查询其他函数的用法

语法 help(函数对象)

# help(print)


def fn(a:int,b:str,c:bool)-> int:

    '''
    :param a: 类型 int 默认值...
    :param b: 类型 str 默认值...
    :param c: 类型 bool 默认值...
    :return: int
    '''

    return 1

help(fn)

三、函数的作用域: 作用域代表指的是变量生效的区域

3.1. 全局作用域

1️⃣ 全局作用域在程序执行时创建，在程序执行结束时销毁

2️⃣ 所有函数以外的部分都是全局作用域

3️⃣ 在全局作用域中定义的变量，都属于全局变量，全局变量可以在程序的任意位置访问

3.2.函数作用域

1️⃣ 函数作用域在函数调用时创建，在调用结束后销毁

2️⃣ 函数每调用一次就会产生一个新的作用域

3️⃣ 在函数作用域中定义的变量都是局部变量，它只能在函数内部被访问到

def fn():

    a = 10  # a定义在函数内部，所以它的作用域是函数内部，函数外部是访问不到的
    print('函数内部：','a =',a)

fn()         # 函数内部： a = 10
print('函数外部：','a =',a)  # 访问不到a， 且会报错

b = 20
def fn():

    a = 10  #
    print('函数内部：','a =',a)
    print('函数内部：','b =',b)

fn()         # 函数内部： a = 10
# print('函数外部：','a =',a)
print('函数外部：','a =',b)
结果：	函数内部： a = 10
		函数内部： b = 20
		函数外部： a = 20

def fn2():
    a = 30
    def fn3():
        a = 40
        print('fn3中:','a = ',a)
    fn3()
fn2()
结果：  fn3中: a =  40

如果希望在函数内部修改全局变量，则需要使用global关键字，来声明变量

a = 20

def fn3():
    # 如果希望在函数内部修改全局变量，则需要使用global关键字，来声明变量
    # a = 10
    global a # 声明在函数内部的使用a是全局变量，在去修改a，是修改的是全局的a
    a = 10
    print('函数内部:','a =',a)

fn3()
print('函数外部:','a =',a)

结果：	函数内部: a = 10
		函数外部: a = 10

四、命名空间：命名空间实际上就是一个字典，是一个专门用来存储变量的字典

1.locals()用来获取当前作用域的命名空间

2.如果在全局作用域中调用locals()则获取的是全局命名空间，如果在函数作用域中调用，则获取的是函数的命名空间， 返回是一个字典

# 向字典中添加key-value 就相当于在全局中创建了一个变量
s = locals() # 当前的命名空空间
s['b'] = 100 # 像字典中添加key-value 就相当于在全局中创建了一个变量
print(b)   #  100
print(s)
结果： {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0053C230>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'H:/计算机要点/函数/函数.py', '__cached__': None, 's': {...}, 'fn': <function fn at 0x02D85270>, 'r': None, 'fn2': <function fn2 at 0x02ECDBB8>, 'fn3': <function fn3 at 0x02D85198>, 'fn4': <function fn4 at 0x02D851E0>, 'fn5': <function fn5 at 0x02D85228>, 'b': 100, 'a': 10}

情况1

def fn4():
    s = locals() # 在函数内部调用locals()会获取到函数的命名空间
    print(s)
fn4()
结果： {}

情况2

def fn4():
    a = 10
    s = locals() # 在函数内部调用locals()会获取到函数的命名空间
    print(s)
fn4()
结果： {'a': 10}

情况3

def fn4():
    a = 10
    s = locals() # 在函数内部调用locals()会获取到函数的命名空间
    s['c'] = 20
    print(s)
fn4()
结果： {'a': 10, 'c': 20}

情况4

def fn4():
    # a = 10
    # s['c'] = 20
    # print(c)
    # globals() 函数可以用来在任意位置获取全局命名空间
    global_space = globals()
    print(global_space)
fn4()
结果： {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0362C230>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'H:/计算机要点/函数/函数.py', '__cached__': None, 's': <function s at 0x037E5078>, 'fn': <function fn at 0x037E5270>, 'r': None, 'fn2': <function fn2 at 0x03A2DBB8>, 'fn3': <function fn3 at 0x037E5198>, 'fn4': <function fn4 at 0x037E5108>, 'fn5': <function fn5 at 0x037E5228>, 'b': 20, 'a': 10}

五、递归

练习：10的阶乘

'''
# 10! 1*2*3*4*5*6*7*8*9*10  = 3628800
# 9!  1*2*3*4*5*6*7*8*9
# ...
# 4!  1*2*3*4               = 24
# 3!  1*2*3                 = 6
# 2!  1*2                   = 2
# 1!  1
'''


# 定义一个函数实现任意数的阶乘
# 创建一个变量保存结果
n = 10
for i in range(1,10):
    # n = n * i
    n *= i
print(n)
# 结果：  3628800

递归式的函数

递归简单理解就是自己调用自己

递归式函数，在函数中自己调用自己

def fn(n):

    # 创建一个变量保存结果
    result = n

    for i in range(1, n):

        result *= i

    return result

print(fn(15))
结果： 1307674368000

无穷递归 类似于死循环

def fn():

    fn()
fn()

递归式函数有两个条件

1.基线条件

问题可以被分解为最小的问题，当满足基线条件的时候，递归就不在执行了

2.递归条件

将问题可以分解的条件

'''
10! 1*2*3*4*5*6*7*8*9*10  -->  10 * 9!
9!  1*2*3*4*5*6*7*8*9     -->  9 * 8!
...
4!  1*2*3*4 = 24          -->  4 * 3!
3!  1*2*3 = 6             -->  3 * 2!
2!  1*2 = 2               -->  2 * 1!
1!  1                     -->  1! = 1
'''


def fn(n):


    # 基线条件  判断n是否是1 如果是1不能再继续递归
    if n == 1:
        # 1的阶乘就是1，直接返回1
        return 1

    # 递归条件

    return n * fn(n-1)

print(fn(19))
结果：121645100408832000

六、递归的练习

练习1、创建一个函数，来为任意数字做幂运算 n ** 1 5 ** 3

'''
10 ** 5 = 10 * 10 ** 4
10 ** 4 = 10 * 10 ** 3
...
10 ** 1 = 10
'''


def fn(n,i):
    # 参数 n:要做幂运算的数字 i 做幂运算的次数
    # 基线条件
    if i == 1:
        # 求1次幂
        return n
    # 递归条件
    return n * fn(n,i-1)
print(fn(5,4))
print(5**4)

练习2

创建一个函数，用来检测任意字符串是否是回文字符串，如果是返回True,如果不是返回False

什么是回文字符串？字符串从后往前读和从后往前读是一样的 例如 abcba abc abcdefgfedcba

1. 先去检测第一个字符和最后一个字符是否一致,如果不一致则不是回文字符串

2. 如果一致，则看剩余部分是否是回文字符串

3. 检查abcdefgfedcba 是不是回文

4. 检查bcdefgfedcb 是不是回文

5. 检查 cdefgfedc 是不是回文

…

6. 检查 fgf 是不是回文

7. 检查 g 是不是回文

def fn2(s):

    # 参数 s 就是用来检测是否是回文字符串 如果是返回True 如果不是返回False

    # 基线条件
    # 如果字符长度小于2，则肯定是回文
    if len(s) < 2:
        return True
    elif s[0] != s[-1]:
        # 第一个字符和最后一个字符不相等 则证明肯定不是回文
        return False


    # 递归条件
    return fn2(s[1:-1])

print(fn2('abba'))