Python零基础之函数二(return、文档字符串、函数作用域、递归函数）

一. 函数的返回值return

• 通过return返回数据数据
• return后边跟随什么数据或变量,函数就返回什么
• return后边可以跟数据类型的值和变量，甚至是函数
• 不写return相当于return None
• return后的代码语句都不会执行

def s(*b):
    r = 0
    for i in b:
        r += i
    # 仅仅是打印无法利用
    print(r)
    # 可以通过return返回函数执行完的结果
    return
s(1,2)

def fn():
    # return 后边跟什么值,函数就返回什么值
    return 123
r = fn()
print(r)
print(fn())

• return后加函数实例

def fn():
    def fn2():
        print('hhh')
    return fn2
r = fn()
print(r)
# 调用函数对象就可以输出
r()

• return后返回代码不执行的实例

def fn3():
    print('hahaha')
    return
    print('123123')
r = fn3()
print(r)

• 函数中break，continue和return的区别示例

def fn4():
    for i in range(5):
        if i == 3:
            # break
            # continue
            return
        print(i)
    print('循环完毕')
fn4()

• 调用函数对象fn和函数返回值fn（）的区别

# fn 是函数对象 打印fn即打印函数对象
# fn() 是调用函数后的返回值,打印fn()即打印返回值
def fn():
    return 123
print(fn,type(fn))
print('*'*20)
fn()
print('*'*20)
print(fn(),type(fn()))

2. 文档字符串

• 用来写在函数里边，描述函数的使用方法和功能
• 通过help（函数）即可显示
• 文档字符串的格式

def fn(a:int,b:str,c:bool):
    '''
    这是一个文档字符串的案例
    参数的作用:
    :param a: 作用...类型...默认值...
    :param b: 作用...类型...默认值...
    :param c: 作用...类型...默认值...
    :return: 有无返回值
    '''
    return 123
help（fn）

3. 函数的作用域

3.1 scope 作用域

• 函数作用域（局部变量）只能在函数内部被访问到，在函数创建时开始，在函数结束时回收
• 全局作用域（全局变量）在整个程序中都可以被访问到
• 示例：

b = 20


def fn():
    a = 10
    print('函数内部', 'a =', a)
    print('函数内部', 'b =', b)


fn()
print('函数外部', 'b =', b)

• 函数嵌套示例：
• 子函数可以访问到母函数的变量,母函数访问不到子函数的变量,单向玻璃

def fn2():
    a = 30
    def fn3():
        a = 80
        print('fn3中','a = ',a)
    fn3()
    print('fn2中', 'a = ', a)
fn2()

3.2 函数内部声明全局变量

语法：global 变量

a = 80
def fn():
	global a
	a = 20
fn()
print(a)

3.3 命名空间

• locals()
• 所有的变量都是保存在字典里边
• 向scope中添加一个key-value(相当于添加一个全局变量)

a = 20
b = 30
# 所有的变量都是保存在字典里边
# 获取当前命名空间
scope = locals()

print(scope)
print(a,b)
print(scope['a'])
# NameError: name 'c' is not defined
# print(c)

# 向scope中添加一个key-value(相当于添加一个全局变量)

scope['c'] = 123
print(c)

• Python不建议直接修改命名空间添加变量
• 通过这种方式添加的变量，在函数内部无法打印出来

b = 30
def fn4():
    a = 20
    # 获取函数内部的命名空间
    scope = locals()
    # 不建议直接修改命名空间添加变量
    scope['b'] = 200
    print(scope)
    print(b)
fn4()

在函数内部显示全局的命名空间

• globals（）

def fn4():
    scope_globals = globals()
    print(scope_globals)
fn4()

4. 递归函数

• 不断的调用自己实现循环调用的递归功能

递归思想是一种把大问题分解为不可分解的小问题的方法。
递归函数的两个条件：

1. 基线条件 问题分解为最小问题，满足基线条件后，终止递归避免死循环
2. 递归条件 将问题继续分解的条件

• 示例：求n的阶乘n！
• 非递归函数写法如下：

# # 尝试求10的阶乘:10!
# n = 10
# for i in range(1,10):
#     n *= i
# print(n)

# 定义递归函数实现任意数的阶乘
def fn(n):
    # 创建一个变量保存结果
    r = n
    # 因为range中的值变为了n,那么变量就不能是n,所以定义了r
    for i in range(1, n):
        r *= i
    return r
print(fn(20))

• 注意避免以下这种调用

# 死循环
# def fn1():
#     fn1()
# fn1()

• 递归函数写法
• 找到两个条件，构造递归函数

def fn2(n):
    # n:阶乘数字

    # 基线条件
    if n == 1:
        #1的递归返回他本身
        return 1
    # 递归条件
    return n * fn2(n-1)
print(fn2(10))

• 练习1
• 做任意数字x的任意y次幂运算

# 定义一个函数 做任意数字的任意幂运算
def fn1(x,y):
    # x: 数字x
    # y: y次幂
    # 基线条件
    if y == 0:
        return 1
    elif y == 1:
        return x
    # 递归条件
    return x * fn1(x,y-1)
print(fn1(3,1))

• 练习2
• 定义一个函数检查一个任意字符串是否为回文字符串,如果是就返回True,不是就返回False
• 回文字符串:从前向后和从后向前念是一样的
• 一般写法：

s = str(input('请输入一个字符串:'))
print('True') if s == s[::-1] else print('False')

• 递归写法1:

def fn2(s):
    if  len(s) < 2:
        return True
    elif s[0] != s[-1]:
        return False
    return fn2(s[1:-1])
print(fn2('abcdadcba?'))

• 递归写法2:

def fn3(s):
    if len(s) < 2:
        return True
    return s[0] == s[-1] and fn3(s[1,-1])
print(fn3('abcdadcba?'))