09-函数二

09-函数二

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

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/9 0009 13:17
# @Author  : Oliver
#可以直接使用函数的返回值，也可以通过一个变量来接收返回值
#return 后面可以跟任意的对象，甚至于是函数
def fn():
    #return 123
    # return 'hello'
    # return {'a':0}
    def fn2():
        print('python')
    return fn2#返回函数对象
r=fn()
r()
#如果仅仅写一个return，或者没有写return就相当于return None
def fn3():
    return
r=fn3()
print(r)
#return一旦执行函数自动结束
def fn4():
    print('python')
    return
    print('abc')
r=fn4()
print(r)

def fn5():
    for i in range(5):
        if i ==3:
            #break
            return #return可以用来结束函数
        print(i)
    print('循环执行完毕')

r=fn5()
print(r)

结果显示：

python
None
python
None
0
1
2
循环执行完毕

Process finished with exit code 0

• 2、文档字符串
  • help()是Python中内置函数，通过help()函数可以查询Python中函数的用法
  • 在定义函数时，可以在函数内部编写文档字符串，文档字符串就是对函数的说明

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/9 0009 13:37
# @Author  : Oliver
'''
help()
通过help（）函数可以查询其他函数的用法
语法：help（函数对象）
'''
#help(print)
def fn(a:int,b:str,c:bool)->int:
    '''
    这个函数的功能就是一个文档字符串的说明

    参数
    a，作用，类型，有没有默认值
    b，作用，类型，有没有默认值
    c，作用，类型，有没有默认值
    返回值：.....

    '''
    return 1
help(fn)

结果显示：

Help on function fn in module __main__:

fn(a: int, b: str, c: bool) -> int
    这个函数的功能就是一个文档字符串的说明
    
    参数
    a，作用，类型，有没有默认值
    b，作用，类型，有没有默认值
    c，作用，类型，有没有默认值
    返回值：.....


Process finished with exit code 0

• 3.、函数的作用域
  • 作用域(scope)
  • 作用域指的是变量生效的区域
  • 在Python中一共有两种作用域
    • 全局作用域
      • 全局作用域在程序执行时创建，在程序执行结束时销毁
      • 所有函数以外的区域都是全局作用域
      • 在全局作用域中定义的变量，都是全局变量，全局变量可以在程序的任意位置进行访问
    • 函数作用域
      • 函数作用域在函数调用时创建，在调用结束时销毁
      • 函数每调用一次就会产生一个新的函数作用域
      • 在函数作用域中定义的变量，都是局部变量，它只能在函数内部被访问

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/9 0009 13:46
# @Author  : Oliver
b=20
def fn():
    #a定义在了函数的内部，所以他的作用域就是函数的内部，函数外部是无法访问到的
    a=10
    print('函数内部：','a=',a)
    print('函数内部：','b=',b)

fn()
#print('函数内部：','a=',a)#NameError: name 'a' is not defined
print('函数外部：','b=',b)
#就像是车贴黑膜，里面看得见外面，外面看不见里面的
def fn2():
    a=30
    def fn3():
        print('fn3中 a=',a)
    return fn3()
fn2()

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

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

结果显示：

函数内部： a= 10
函数内部： b= 20
函数外部： b= 20
fn3中 a= 30
函数内部a= 100
函数外部a= 100

Process finished with exit code 0

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

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/9 0009 14:15
# @Author  : Oliver

#命名空间就是一个字典，是一个专门用来存储变量的
#通过locals（）来获取当前作用域的命名空间，返回是一个字典

a=20
scope=locals()
print(scope)
print(scope['a'])

scope['c']=1000
print(c)#虽然会有警告，但是运行的时候是不会显示错误的

def fn1():
    a=50
    scope=locals()

    print(scope)
fn1()#获取的是函数内部的，所以会是空的

def fn4():
    a=50
    scope=locals()
    scope['c']=1000
    print(scope)
    #print(c)这句话是会报错的，这就和之前的全局的有差别，但是从上面的scope来看，c确确实实的已经添加进去了
    print(scope['c'])#这样才是可以的
fn4()

#都添加进去
b=100
def fn5():
    a=50
    g=globals()
    print(g)
fn5()

结果显示：

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001A167E91880>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/demo/命名空间.py', '__cached__': None, 'a': 20, 'scope': {...}}
20
1000
{'a': 50}
{'a': 50, 'c': 1000}
1000
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001A167E91880>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/demo/命名空间.py', '__cached__': None, 'a': 20, 'scope': {...}, 'c': 1000, 'fn1': <function fn1 at 0x000001A167FDD0D0>, 'fn4': <function fn4 at 0x000001A167FDD1F0>, 'b': 100, 'fn5': <function fn5 at 0x000001A167FDD280>}

Process finished with exit code 0

• 5、递归函数
  • 递归是解决问题的一种方式，它的整体思想，是将一个大问题分解为一个个的小问题，直到问题无法分解时，在去解决问题
  • 递归式函数有2个条件
    • 1、基线条件 问题可以被分解为最小问题，当满足基线条件时，递归就不执行了
    • 2、递归条件 可以将问题继续分解的条件

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/9 0009 14:33
# @Author  : Oliver

#尝试求10的阶乘
print(1*2*3*4*5*6*7*8*9*10)#3628800

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

#想求任意数的阶乘
#定义一个函数 求任意数的阶乘
def fn(n):
    #参数n表示要求阶乘的数字
    #定义一个变量来保存结果
    r=n
    for i in range(1, n):
        r *= i
    return r
print(fn(10))

#递归是解决问题的一种方式
#和循环非常的像
#他的整体思想：是将大的问题分解为一个个小问题，直到问题无法分解时，再去解决问题
#递归式函数
#递归简单理解就是自己调用自己
#递归式函数就是在函数中自己调用自己
#递归函数有两个条件
#1.基线条件
#问题可以被分解为最小的问题，当满足基线条件时，递归就不再执行了
#2.递归条件
#用递归的方式来解决，任意数的阶乘
def fn3(n):
    #1.基线条件  判断用户让求的数字是1的话，我们就满足基线条件，就不再递归了
    if n==1:
        #1的阶乘就是1
        return 1
    #2.递归条件
    return n * fn3(n-1)
print(fn3(10))

##练习
#定义一个函数来为任意数字做幂运算n**i
def fn4(n,i):
    #1.基线条件
    if i==1:
        return n
    #2.递归条件
    return n * fn4(n,i-1)
print(fn4(10,5))

结果显示：

3628800
3628800
3628800
3628800
100000

Process finished with exit code 0

• 课堂作业：
  • 定义一个函数，用来检查一个任意的字符串是否是回文字符串，如果是返回True,不是返回False。回文字符串从前往后念和从后往前念是一样的。例如 TNT

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/9 0009 15:12
# @Author  : Oliver

# 定义一个函数，
# 用来检查一个任意的字符串是否是回文字符串，
# 如果是返回True,不是返回False。
# 回文字符串从前往后念和从后往前念是一样的。
# 例如 TNT
n=input('请输入一个字符串：')
str=n[::-1]
if n==str:
    print(n,'是一个回文字符串！！')
else:print(n,'不是一个回文字符串！！')