09-函数(中)

最新推荐文章于 2023-04-22 15:03:52 发布

无痕的雨

最新推荐文章于 2023-04-22 15:03:52 发布

阅读量302

点赞数

分类专栏： python 基础

本文链接：https://blog.csdn.net/qq_45451647/article/details/108911687

版权

python 基础专栏收录该内容

16 篇文章 0 订阅

订阅专栏

课堂笔记

1. 函数的返回值

返回值就是函数执⾏以后返回的结果

                     (计算任意参数和的函数返回值)

def fn(*args):
    r=0
    print(args)#元组
    for i in args:
   	   r+=i
    return r
    

   
print(fn(1,2,3))

(1,2,3)
6

在这里插入图片描述

通过return来指定函数的返回值

                    (通过return函数返回了一个'python'的字符串)

def fn(*args):
    r=0
    print(args)#元组
    for i in args:
       r+=i
    return 'python'

print(fn(1,2,3))

python

return后⾯可以跟任意对象，返回值甚⾄可以是⼀个函数
（函数的两种方式返回）
```
                   （方式一）
```

def fn(*args):
    r=0
    print(args)#元组
    for i in args:
        return 123
        r+=1
        print(r)
    def fn1():

        print("我是fn1")
        return {"a":123}
    return fn1

s=fn()
#print(fn(1,2,3,4))
print(s())

()
我是fn1
{'a': 123}

                         （方式二）

def fn(*args):
    r=0
    print(args)#元组
    for i in args:
        
        r+=1
        print(r)
    def fn1():

        print("我是fn1")
        return {"a":123}
    return fn1()

s=fn()
#print(fn(1,2,3,4))
print(s)

()
我是fn1
{'a': 123}

当你不写return语句，和只写一个return语句时，返回值为None

            fn1()与fn2()  fn1只有一个return    fn2() 无return

def fn1(*args):

    return

def fn2():
    a=1


print("有return",fn1())#有return None
print("无return",fn2())#无return None

#当你不写return语句，和只写一个return语句时，返回值为None

有return None
无return None

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

#在函数中return 后面的代码不在执行
def fn():
    print("return 前")
    return 123
    print("return 后")#return 前
                      #123

s=fn()
print(s)

return 前
123

循环中插入return语句其所有后面的语句不会执行

# break和continue 一定只能在循环中使用，只会对当次循环起效果
def fn():
    for i in range(9):
        print("abc")
        return f"第{i}次结束"
        print("123")
        if i==5:
            break
            return
        print( i)
    print("循环执行结束")
r=fn()
print(r)

#abc
#第0次结束

abc
第0次结束

循环中break在return前return不会执行

#有return 函数提前结束
def fn():
    for i in range(9):
        print("abc")

        print("123")
        if i==5:
            break
            return
        print( i)
    print("循环执行结束")
r=fn()
print(r)

abc
123
0
abc
123
1
abc
123
2
abc
123
3
abc
123
4
abc
123
循环执行结束
None

2. ⽂档字符串

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

def fn(a,b,c):
    #文档字符串是为了解释清楚一个自定义函数，各个参数有啥用
    """

    :param a:#作用 类型 默认值
    :param b:作用 类型 默认值
    :param c:作用 类型 默认值
    :return: 需不需要
    """
    return 123

help(fn)#简单的介绍

help(fn(a=1,b=2,c=4))#细致的介绍

简单的介绍help(fn)

Help on function fn in module __main__:

fn(a, b, c)
    :param a:#作用 类型 默认值
    :param b:作用 类型 默认值
    :param c:作用 类型 默认值
    :return: 需不需要

复杂的介绍help(fn(a=1,b=2,c=4))

class int(object)
 |  int(x=0) -> integer
 |  int(x, base=10) -> integer
 |  
 |  Convert a number or string to an integer, or return 0 if no arguments
 |  are given.  If x is a number, return x.__int__().  For floating point
 |  numbers, this truncates towards zero.
 |  
 |  If x is not a number or if base is given, then x must be a string,
 |  bytes, or bytearray instance representing an integer literal in the
 |  given base.  The literal can be preceded by '+' or '-' and be surrounded
 |  by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
 |  Base 0 means to interpret the base from the string as an integer literal.
 |  >>> int('0b100', base=0)
 |  4
 |

3. 函数的作⽤域

作⽤域(scope)

#函数作用域：概念：指的是变量生效的区域
#变量在函数内部的话，不能拿到函数外部使用
def fn():
    a=123
    print('函数内部：a=',a)

fn()#函数内部：a= 123
print('函数外部：a=',a) #调用不了a变量

Traceback (most recent call last):
函数内部：a= 123
   File "C:/Users/dell/PycharmProjects/untitled11/Day7/2.函数作用域.py", line 8, in <module>
     print('函数外部：a=',a) #调用不了a变量
 NameError: name 'a' is not defined

 Process finished with exit code 1

        （显示报错）

作⽤域指的是变量⽣效的区域
在Python中⼀共有两种作⽤域

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

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

b=456
a=b

def fn():
    global a
    a=123

print("fn前")
print("函数内部：a=",a)
print("函数外部：b=",b)
fn()
print("fn后")
print("函数内部：a=",a)
print("函数外部：b=",b)

fn前
函数内部：a= 456
函数外部：b= 456
fn后
函数内部：a= 123
函数外部：b= 456

在这里插入图片描述

4. 命名空间

命名空间实际上就是⼀个字典，是⼀个专⻔⽤来存储变量的字典
locals()⽤来获取当前作⽤域的命名空间
如果在全局作⽤域中调⽤locals()则获取全局命名空间，如果在函数作⽤域中
调⽤locals()则获取函数命名空间
返回值是⼀个字典
（全局变量中）

#全局变量中
a=1
b=2
c=3
d=4
#e=5
scope=locals()
print(scope) 

scope['e']=5
print(e)#5
print(scope)

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000257967CA470>,
              '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>,
              '__file__': 'C:/Users/dell/PycharmProjects/untitled11/Day7/3.命名空间.py', '__cached__': None,
              'a': 1, 'b': 2, 'c': 3, 'd': 4, 'scope': {...}}

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000257967CA470>,
              '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>,
              '__file__': 'C:/Users/dell/PycharmProjects/untitled11/Day7/3.命名空间.py', '__cached__': None,
              'a': 1, 'b': 2, 'c': 3, 'd': 4, 'scope': {...}, 'e': 5}

（函数中）

#函数作用域中
def fn():
    a=1
    b=2
    c=3
    d=4
    scope=globals() #globals()函数可以获取整个进程的全部全局变量
    scope['e']=5
    print(e)
    print(scope)

fn()

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000020A99ABA470>,
                 '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/dell/PycharmProjects/untitled11/Day7/3.命名空间.py', 
                 '__cached__': None, 'a': 1, 'b': 2, 'c': 3, 'd': 4, 'scope': {...}, 'e': 5, 'fn': <function fn at 0x0000020A99A61E18>}

5. 递归函数

递归是解决问题的⼀种⽅式，它的整体思想，是将⼀个⼤问题分解为⼀个个
的⼩问题，直到问题⽆法分解时，在去解决问题

#递归是解决问题的一种方式，它的思想，是将一个大问题分解为一个个的小问题，直到问题无法分解时，在去解决问题

#求10的阶乘

#函数用循环解决
def fn(n):
    for i in range(1,n):
        n*=i

    return n

r=fn(10)#3628800
print(r)


递归就是，从前有座山，山上有个庙，庙里有个小和尚和老和尚，老和尚对小和尚讲故事：
从前有座山，山上有个庙，庙里有个小和尚和老和尚，老和尚对小和尚讲故事：······
递归的简单理解：自己调用自己

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

#无穷递归
"""
def fn():
    return fn()

fn()
"""

#递归的两个条件：
#1.基线条件，问题无法在分解的问题，当满足基线条件的时候，递归就不在执行了
#2.递归条键，可以将问题继续分解的条件

def fn(n):#定义的fn()就是要计算n的阶乘
    #基线条件
    if n==1:
        return 1
    return n*fn(n-1)
r=fn(10)
print(r)#r=10*9*8*7*6*5*4*3*2*1 3628800

在这里插入图片描述

递归练习

#定义一个函数，用来检测任意一个字符是否为回文字符串
#efffhfffe 回文
#abcdedcba
str1="abcdedcba"
print(str1[1:-1])#对称打印 半开区间
def fn2(str1):
    if len(str1)<2:
        return  True
    elif str1[0]!=str1[-1]:
        return False
    else:
       
        return fn2(str1[1:-1])

print(fn2(str1))

bcdedcb
True

作业

#用一个函数实现一个判断用户输入的年份是否是闰年的程序

#1.能被4整除，



def fn(a):
    if a%4==0:
        print("该年为闰年")
    else:
        print("该年不为闰年")

while True:
    a=eval(input("请输入年份："))
    fn(a)

C:\Users\dell\PycharmProjects\untitled11\venv\Scripts\python.exe C:/Users/dell/PycharmProjects/untitled11/Day7/作业/1题.py
请输入年份：2001
该年不为闰年
请输入年份：2000
该年为闰年
请输入年份：2020
该年为闰年
请输入年份：2010
该年不为闰年
请输入年份：2012
该年为闰年
请输入年份：2008
该年为闰年
请输入年份：



def houzi(date):
    if date==10:
        a=1
        print(f"{date}天，吃了{a}")
        return a
    else:
        a= 2*(houzi(date+1)+1)
        print(f"{date}天，吃了{a}")
        return a




print("一共摘了:",houzi(1))

C:\Users\dell\PycharmProjects\untitled11\venv\Scripts\python.exe "C:/Users/dell/PycharmProjects/untitled11/python程序设计习题/第五章 循环结构/作业.py"
10天，吃了1
9天，吃了4
8天，吃了10
7天，吃了22
6天，吃了46
5天，吃了94
4天，吃了190
3天，吃了382
2天，吃了766
1天，吃了1534
一共摘了: 1534

Process finished with exit code 0