2020-09-30

我的博客第九篇

1.函数的返回值
。返回值就是函数执行以后返回的结果
。通过return来指定函数的返回值
。返回值的作用就是便于我们再去做另外的操作

#求任意数的和
def fn(*args):
    r = 0
    for i in args:
        r += i
    return r
s = fn(1,2,3,4)
print(s) 
#结果
10
#不加return r 结果如下：
#求任意数的和
def fn(*args):
    r = 0
    for i in args:
        r += i
#    return r
s = fn(1,2,3,4)
print(s) 
#结果
None

。return后面可以跟任意对象，返回值甚至可以是一个函数。和函数的参数比较相似

def fn(*args):    
    def fn1():
        print('我是fn1')
    return fn1

s = fn()
print(s)
#结果
<function fn.<locals>.fn1 at 0x00000292032836A8>  #返回的是一个fn1对象

def fn(*args):    
    def fn1():
        print('我是fn1')
        return {'a':123}
    return fn1
s = fn()
print(s)
#结果
<function fn.<locals>.fn1 at 0x00000292041C3C80> #同样返回的是一个fn1对象，因为print(s)  "s"里面需要加上括号

#如果需要函数嵌套返回值时 里面一定要加上括号：
def fn(*args):    
    def fn1():
        print('我是fn1')
        return {'a':123}
    return fn1
s = fn()
print(s())
#结果
我是fn1
{'a': 123}

#在函数体内部，当你不写return语句和只写一个return的时候，返回值是None
def fn(*args):
    def fn1():
        print('我是fn1')
        return [1,1,2,3,4,]
#    return fn1
s = fn()
print(s)
#结果
None

def fn(*args):
    def fn1():
        print('我是fn1')
        return [1,1,2,3,4,]
    return 
s = fn()
print(s)
#结果
None

。在函数中return后面的代码不在执行

def fn():
    print('abc')
    return
    print(123)    
r = fn()
print(r)
#结果
abc
None

def fn():
    for i in range(9):
        if i == 5:
#            return  不加return的结果
            print(i)
    print('循环执行完毕')
r = fn()
print(r)
#结果
5
循环执行完毕
None

def fn():
    for i in range(9):
        if i == 5:
            return		#加上return的结果
            print(i)
    print('循环执行完毕')
r = fn()
print(r)
#结果
None

。break和continue一定只能在循环中使用，只会对当次循环起效果

#break
def fn():
    for i in range(9):
        if i == 5:
            break
        print(i)
    print('循环执行完毕')       
r = fn()
print(r)
#结果
0
1
2
3
4
循环执行完毕
None

#continue
def fn():
    for i in range(9):
        if i == 5:
            continue
        print(i)
    print('循环执行完毕')
r = fn()
print(r)
#结果
0
1
2
3
4
6
7
8
循环执行完毕
None

** 2.文档字符串**
。help()是Python中内置函数，通过help()函数可以查询Python中函数的⽤法
。语法
。def fn():
“”"
这里就是文档字符串
“”"
。文档字符串的作用：给函数做一个功能的声明，参数的说明，返回值的说明

def fn(a,b,c):
    """
    #这是一个文档字符串的说明
    通常我们用来对函数进行解释说明的
    :param a: 作用 类型 默认值 等等
    :param b: 作用 类型 默认值 等等
    :param c: 作用 类型 默认值 等等
    :return: 需要不需要
    """
    return 123
help(fn)
#结果
fn(a, b, c)
    #这是一个文档字符串的说明
    通常我们用来对函数进行解释说明的
    :param a: 作用 类型 默认值 等等
    :param b: 作用 类型 默认值 等等
    :param c: 作用 类型 默认值 等等
    :return: 需要不需要

3.函数的作用域
。作用域(scope)
。作用域讲的就是变量的作用范围（变量生效的区域）

#变量在函数内部的话，不能拿到函数外部使用
def fn():
    a = 123   
    print('函数内部：a = ', a)

fn()
print('函数外部：a = ', a)
#结果
Traceback (most recent call last):
函数内部：a =  123
  File "E:/练习.py", line 7, in <module>
    print('函数外部：a = ', a)
NameError: name 'a' is not defined

Process finished with exit code 1

。在python中有两种作用域
。全局作用域（就是在函数之外的变量的作用域）任意位置都可以调用
。全局作用域在程序执行时创建，在程序执行结束时销毁（python垃圾回收机制：引用计数的功能，当计数为0的时候，就会销毁变量）
。所有函数以外的区域都是全局作用域（相对的，函数嵌套）
。在全局作用域中定义的变量，都是全局变量，全局变量可以再程序的任意位置进行访问

。局部作用域（就是在函数内部的变量的作用域）只能在函数的里面使用，在函数的签到函数里同样可以使用

b = 456
def fn():
    a = 123  #局部作用域
    print('函数内部：a = ', a)
    print('函数内部：b = ', b)
fn()
print('函数外部：b = ', b)
#结果
函数内部：a =  123
函数内部：b =  456
函数外部：b =  456

。global可以将局部作用域声明为全局作用域

b = 456
def fn():
    global a
    a = 123

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

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

4.命名空间
。命名空间实际上是一个字典，是一个专门用来存储变量的字典
。locals()用来获取当前作用域的命名空间，返回值是一个字典

a = 1
b = 2
c = 3
scope = locals()
print(scope)
#结果
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader 等等等 '__cached__': None, 'a': 1, 'b': 2, 'c': 3, 'scope': {...}}

def fn():
    a = 1
    b = 2
    c = 3
    scope = locals()
    print(scope)
fn()
#结果
{'c': 3, 'b': 2, 'a': 1}

5.递归函数
。递归函数是解决问题的一种方式，它的整体思想是将一个大问题分解为一个个的小问题，直到问题无法分解时，再去解决问题。

#求10的阶乘（10！）
#1！ = 1
#2！= 1*2
#10！ = 1*2*3*4*5*6*7*8*9*10
#方法1：
print(1*2*3*4*5*6*7*8*9*10)  #这种方法一般不会采用
#方法2：
n = 10
for i in range(1,10):  #当需要求任意数的阶乘的时候 "10"需要不断的更换
    n *= i
print(n)
#结果
3628800

#以上两种方式不符合代码的思想（不能将使用的数据写死，要去灵活的运用）

def fn(n):
    for i in range(1,n):
        n *=i

    return n
r = fn(10)
print(r)

。递归思想：
#从前有座上，上里有座庙，庙里有个老和尚和小和尚，老和尚给小和尚讲故事
#从前有座上，上里有座庙，庙里有个老和尚和小和尚，老和尚给小和尚讲故事
#从前有座上，上里有座庙，庙里有个老和尚和小和尚，老和尚给小和尚讲故事
#。。。。。。
#递归的简单理解：自己调用自己

#无穷递归，导致内存溢出 报错
def fn(n):
    return fn()
fn()
#TypeError: fn() missing 1 required positional argument: 'n'

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

# 10！ = 10*9！    n! = n * (n-1)!
# 9！ = 9*8！
# 。。。      #可以继续分解 （递归条件）
# 1！ = 1   #无法再分解 （基线条件）
#当以上两个条件都满足时，就可以用递归思想处理问题

def fn(n):  #定义的fn()就是要做计算n的阶乘
    #基线条件
    if n == 1:
        return 1
    #递归条件 (自己调用自己)
    return n * fn(n-1)
r = fn(10)
print(r)

#定义一个函数，为任意数字做任意的幂运算
# n ** m
# n ** m = n *(n**m-1)
# 10 ** 5 = 10 * (10**5-1) = 10 * 10**4
#......
#m = 1

#10 **5
#10 **5 = 10 * 10**4
#10 **4 = 10 * 10**3
#10 **3 = 10 * 10**2
#10 **2 = 10 * 10**1
#10 **1 = 10

def fn(n,m):
    if m == 1:
        return n
    return n * fn(n,m-1)
r = fn(10,8)
print(r)
#结果
100000000

#定义一个函数，用来检查任意一个字符串是不是一个回文字符串，如果是返回True，不是返回False
#abcdefghgfedcba 判断是不是回文字符串
#bcdefghgfedcb
#cdefghgfedc
#defghgfed
#efghgfe
#fghgf
#ghg
#h

def fn1(str1): #fn1()判断字符串是不是回文字符串
    #基线条件
    if len(str1) < 2:
        return True
    elif str1[0] != str1[-1]:
        return False
    #递归条件
    return fn1(str1[1:-1])  #-1 最后一个是取不到的

r = fn1('abcdefghgfedcba')
print(r)
#结果
True

作业：

1.用函数实现一个判断用户输入的年份是否是闰年的程序
1.能被400整除的年份
2.能被4整除，但是不能被100整除的年份
以上2中方法满足一种即为闰年
方法1：

def fn():
    a = int(input('请输入一个年份我就可以帮你判断是否是闰年：'))
    if a % 400 == 0 or a % 4 == 0 and a % 100 != 0:
        print('您输入的年份{}是闰年'.format(a))
        return True
    else:
        print('您输入的年份{}不是闰年'.format(a))
        return False
r = fn()
print(r)

方法2：

def runnian(year):
    if year % 400 == 0:
        print('{}是闰年'.format(year))
    elif year % 4 == 0 and year % 100 !=0:
        print('{}是闰年'.format(year))
    else:
        print('不是闰年')

if __name__ == '__main__':
    while True:
        year = int(input('请输入年份：'))
        runnian(year)

2.猴子吃桃问题（递归）:
猴子第一天摘下若干个桃子，当即吃了一半，不过瘾，又多吃了一个。第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩的一半零一个。到第10天早上再想吃时，见只剩下一个桃子了，求第一天共摘了多少桃子？
方法1：

#day10 = 1
#day9 = n*1/2 - 1 = 1     n=4
#day8 = (n+1)*2           n=10
#day7 = (n+1)*2           n=22
#day6 = (n+1)*2           n=46
#day5 = (n+1)*2           n=94
#day4 = (n+1)*2           n=190
#day3 = (n+1)*2           n=382
#day2 = (n+1)*2           n=766
#day1 = (n+1)*2           n=1534
def fn(n):

    if n > 10 or n < 1:
        return
    elif n == 10:
        return 1
    else:
        return (fn(n+1)+1)*2
r = fn(1)
print(r)
#结果
1534

方法2：

#1(当天):1
#2(昨天):(1+1)*2
#3(前天):(4+1)*2


def chitao(n):#定义第多少天之前有多少个桃
    if n == 1:
        return 1
    return (chitao(n-1) + 1) * 2

r = chitao(10)
print(r)