Python-函数(二)

1. 函数的返回值

.返回值就是函数执行以后返回的结果
.通过return来指定函数的返回值
.return后面可以跟任意对象，返回值甚至可以是一个函数。

#1. 求任意数的和
def fn(*nums):
    result = 0
    for n in nums:
        result += n
    # print(result)
    return result
r = fn(1,2)
#2.break和return的区别
 def fn4():
    for b in range(5):
        if b == 3:
            # break#用来结束循环
            return # 用来结束函数
         print(b)
     print('循环执行完毕')

 fn4()
# 3.fn5和fn5()的区别
def fn5():
    return 100
print(fn5)
print(fn5())
# fn5是函数对象
# fn5()是在调用函数

2.文档字符串

help()是Python中内置函数，通过help()函数可以查询Python中函数的用法。

help(print)

结果：

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

print('www','baidu','com',sep='.')

在定义函数时，可以在函数内部编写文档字符串，文档字符串就是对函数的说明。

def fn(a:bool,b:int,c:str)->int:
    '''
    这个函数式一个文档字符串的实例
     参数
        a:作用 类型 默认值......
        b:作用 类型 默认值......
        c:作用 类型 默认值......
    '''
   return 100
 help(fn)

3.函数的作用域

作用域(scope)：作用域指的是变量生效的区域。
在Python中一共有两种作用域：
1.全局作用域：
全局作用域在程序执行时创建，在程序执行结束时销毁。
所有函数以外的区域都是全局作用域。
在全局作用域中定义的变量，都是全局变量，全局变量可以在程序的任意位置进行访问。

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

2.函数作用域：
函数作用域在函数调用时创建，在调用结束时销毁。函数每调用一次就会产生一个新的函数作用域。
在函数作用域中定义的变量，都是局部变量，它只能在函数内部被访问。

 b = 50
 def fn():
  # a定义在了函数的内部，所以它的作用域就是函数内部，函数外部是无法访问的
    a = 10
     print('函数内部:','a = ',a)
     print('函数内部:', 'b = ', b)
 fn()
 print('函数外部:','a = ',a) #NameError: name 'a' is not defined
 print('函数外部:','b = ',b)

4.命名空间

命名空间实际上就是一个字典，是一个专门用来存储变量的字典。
locals()用来获取当前作用域的命名空间。
如果在全局作用域中调用locals()则获取全局命名空间；如果在函数作用域中调用locals()则获取函数命名空间。
注意：命名空间返回值是一个字典

a = 20
def fn3():
    global a
    a = 50
    print('函数内部:','a =',a)
s = locals()
print(s)

结果：

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000002A6176D0880>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/zjb/PycharmProjects/pyth/2.py', '__cached__': None, 'a': 20, 'fn3': <function fn3 at 0x000002A61787C8B0>, 's': {...}}

def fn4():
    a = 10
    s = locals() # 获取函数内部的命名空间
    s['b'] = 20
    print(s)
    global_s = globals()
    global_s['a'] = 30
    print(global_s)
fn4()
print(a)

结果：

{'a': 10, 'b': 20}
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001D4F2FB0880>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/zjb/PycharmProjects/pyth/2.py', '__cached__': None, 'fn4': <function fn4 at 0x000001D4F4C6C8B0>, 'a': 30}
30

5. 递归函数

递归是解决问题的一种方式，它的整体思想，是将一个大问题分解为一个个的小问题，直到问题无法分解时。
在去解决问题递归式函数有2个条件：

1. 基线条件： 问题可以被分解为最小问题，当满足基线条件时，递归就不执行了。
2. 递归条件： 可以将问题继续分解的条件。

#求n的阶乘
def fn2(n):
    # 参数 n要求阶乘的数字
    # 1.基线条件
    if n == 1:
        # 1的阶乘就是1 直接返回结果
        return 1
    # 2.递归条件
    return n * fn2(n-1)
print(fn2(10))
3628800
#方法二：
def fn1(n):
    # 参数n 要求阶乘的数字
    # n = 10
    # 定义一个变量 保存结果
    result = n
    for i in range(1,n):
        result *= i
    return result
print(fn1(300))

#创建一个函数来为任意数字做任意幂运算
# 10**6 = 10 * 10**5
# 10**5 = 10 * 10**4
# 10**4 = 10 * 10**3
# 10**3 = 10 * 10**2
# ......
# 10**1 = 10
def fn(n,i):
    # 参数 n 要做幂运算的数字 i 要做幂运算的次数
    # 1. 基线条件
    if i == 1:
        return n
    # 2. 递归条件
    return n * fn(n,i-1)
print(fn(5,5))
print(5**5)

# 定义一个函数用来检测一个任意字符是否是回文字符如果是返回True,如果不是返回False
# 回文字符串，字符串从前往后念和从后往前念是一样的
# abcdefgfedcba
# 先检查第一个字符和在最后一个字符是否一致，如果不一致一定不是回文字符串
# 如果一致就要检查剩余的部分是不是回文字符串
# bcdefgfedcb 是不是回文
# cdefgfedc
# defgfed
# efgfe
# fgf
# g
def fn2(s):
    # 参数s就是要检查的字符串
    # 1.基线条件
    # 字符串的长度小于2 则字符串一定是个回文
    if len(s)<2:
        return True
    # 第一个字符和最后一个字符不相同，则一定不是回文字符串
    elif s[0] != s[-1]:
       return False
    # 2.递归条件
    return s[0] == s[-1] and fn2(s[1:-1])
print(fn2('abcdefgfedcba'))

# 定义一个函数解决汉诺塔问题
def hannuoTower(num,a,b,c):
    # 参数 num 代表的是盘子 a b c分别代表的是A柱 B柱 C柱
    # 第一个条件 基线条件
    # 如果只有一个盘子 A --> C
    if num == 1:
        print('第 1 个盘子从',a,'->',c)
    else:
        # 第二个条件 递归条件
        # num >= 2的情况
        # 2.1 先把最上面的盘子 A --> B 借助C柱 num-1 除去最下面的那个盘子
        hannuoTower(num-1,a,c,b)
        # 2.2 把最下面的盘子 A --> C
        print('第',num,'个盘从',a,'->',c)
        # 2.3 把B柱上的盘子  B --> C
        hannuoTower(num-1,b,a,c)
hannuoTower(3,'A','B','C')