python函数精讲（2）

函数的返回值return

• 函数的返回值 返回值就是函数执⾏以后返回的结果
• 通过return来指定函数的返回值
• return后⾯可以跟任意对象，返回值甚⾄可以是⼀个函数
• 在函数中，return一旦执行，函数自动结束，所以return之后的代码皆不会执行
• 如果一个函数没有return语句，那这个函数的返回值就为None，代表这个函数没有运行结果

def fn(*args):    #定义函数fn，形参接收所有实参

    r = 0        

    for n in args:   

        r += n

    # print(r)
    return r
r = fn(1,2,3)   #用r接收函数fn
print(r)    #打印r

6

return 与 print区别

• 打印函数名print（a）,结果是把该函数的内存地址打印出来了。

• 打印函数的执行：print（a( )）,打印该函数的执行程序中的print的部分，最后把return的内容也打印出来，没有定义return的函数打印None。

• 扩展：函数只有被调用或者执行的时候才会产生返回值的，不调用的时候就是放在内存中的代码主体的一部分。

• 当return中有执行的函数的返回值问题的取值
  
  代码运行原理：

print（b） 打印变量b（函数）的内存地址，不会对b函数有任何的影响，b函数不会执行。
 print( b() ) ：

   《1》先执行b 函数  ，由于b函数没有定义主体内容，返回空

   《2》打印b函数的返回值：return a() ，由于此时的b函数在运行的，所以return里面的函数也会运行。

   《2.1》，运行 a()  ,打印 111出来。

   《2.2》，由于a() 函数里面没有定义return的值，取none作为a（）函数的返回值， 也把这none return 给b函数。此时的b函数的返回值也是none，所以print（b()）= None  

文档字符串

• help()是Python中内置函数，通过help()函数可以查询Python中函数的⽤法
• 在定义函数时，可以在函数内部编写⽂档字符串，⽂档字符串就是对函数的 说明
• 在定义函数的时候，可以在函数内部编写文档字符串，文档字符串就是函数的说明
• 当编写了文档字符串时，就可以通过help()函数来查看函数说明（当有了工作岗位之后，开发程序就是一个团体工作，而这时，文档字符串的作用就体现出来了，可以配合说明来更加有效的配合工作）
  实例1：

help(print)

Help on built-in function print in module builtins:

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.

实例2：

def fn(a:bool,b:int,c:str)-> int:  #a传递一个布尔类型，b传递整数类型，c传递字符串类型，返回值为整数类型

    '''
    这是一个文档字符串的示例

    这个函数的作用.......
    函数的参数
    :param a: 作用 类型 默认值...
    :param b: 作用 类型 默认值...
    :param c: 作用 类型 默认值...
    :return:  需要/不需要
    '''
    return 123

help(fn)

Help on function fn in module __main__:

fn(a: bool, b: int, c: str) -> int
    这是一个文档字符串的示例
    
    这个函数的作用.......
    函数的参数
    :param a: 作用 类型 默认值...
    :param b: 作用 类型 默认值...
    :param c: 作用 类型 默认值...
    :return:  需要/不需要

作用域

作⽤域指的是变量⽣效的区域

全局作用域

• 全局作⽤域在程序执⾏时创建，在程序执⾏结束时销毁
• 所有函数以外的区域都是全局作⽤域
• 在全局作⽤域中定义的变量，都是全局变量，全局变量可以在程序的任意 位置进⾏访问
  例如：

a = 1
def fn():
    print(a)
fn()

1

函数作用域

• 函数作⽤域在函数调⽤时创建，在调⽤结束时销毁
• 在函数内部声明的变量为局部变量，函数外部不可进行调用，否则会报错
• 函数每调⽤⼀次就会产⽣⼀个新的函数作⽤域
• 在函数作⽤域中定义的变量，都是局部变量，它只能在函数内部被访问
  例：

ef fn():
    
    a = 5
    print(a)
fn()
print(a)

-Traceback (most recent call last):
  File "C:/Users/小许先生/Desktop/新建文本文档.py", line 6, in <module>
    print(a)
NameError: name 'a' is not defined
5

NameError: name 'a' is not defined
错误信息：NameError:没有定义名称“a”

将局部变量变为全局变量：global关键字
例如：

def fn():
    global a
    a = 5
    print(a)
fn()
print(a)

5
5

命名空间

• 在Python中，所有的名字都存在一个空间中，它们在该空间中存在和被操作——这就是命名空间。它就像一个盒子，每一个变量名字都对应装着一个对象。当查询变量的时候，会从该盒子里面找到相应的对象。
• 命名空间实际上就是⼀个字典，是⼀个专⻔⽤来存储变量的字典
• locals()⽤来获取当前作⽤域的命名空间
• 如果在全局作⽤域中调⽤locals()则获取全局命名空间，如果在函数作⽤域中 调⽤locals()则获取函数命名空间 返回值是⼀个字典
• glaobals() 可以调出全局的命名空间

a = 1
b = 2
scope = locals()     #当前作用域的命名空间
def fn():
    scopes = globals()   #全局的命名空间
    print(scopes)
print(scope)
print('-'*120)  #用---隔开两个结果
fn()

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000013540790910>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/小许先生/Desktop/新建文本文档.py', '__cached__': None, 'a': 1, 'b': 2, 'scope': {...}, 'fn': <function fn at 0x00000135423C8310>}
------------------------------------------------------------------------------------------------------------------------
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000013540790910>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/小许先生/Desktop/新建文本文档.py', '__cached__': None, 'a': 1, 'b': 2, 'scope': {...}, 'fn': <function fn at 0x00000135423C8310>}

发现两个作用域相同

递归函数

• 递归是解决问题的⼀种⽅式，它的整体思想，是将⼀个⼤问题分解为⼀个个 的⼩问题，直到问题⽆法分解时
• 通俗来讲就是自己引用自己：从前有座山，山里有座庙，庙里有个老和尚在给小和尚讲故事，讲的是从前有座山，山里有座庙，庙里有个老和尚在给小和尚讲故事…

条件

• 在去解决问题 递归式函数有2个条件：
• 1. 基线条件 问题可以被分解为最⼩问题，当满⾜基线条件时，递归就不 执⾏了
• 2. 递归条件 可以将问题继续分解的条件

经典递归练习

求10 的阶乘

n = 1
for i in range(1,10):

    n *= i

print(n)

362880

求任意数阶乘

def fn(n):
    r = n

    for i in range(1, n):
        # print(i)
        r *= i

    return r

例如10

print(fn(10))

362880

用递归求任意数阶乘

def fn2(n):

    # 1. 基线条件
    if n == 1:
        return 1
    # 2. 递归条件  9 * 8!

    return  n * fn2(n-1)

print(fn2(10)) 

```python
3628800

判断回文字符串

def fn(n):
    #基线条件
    if len(n)>2:
        return True
    elif n[-1] != n[0]:
        return False
    #递归条件
    if n[1:-1] == n[-1:1]:
        return True
n = input('请输入需要判断的字符串：')
print(fn(n))

请输入需要判断的字符串：12321
True