day08 Python函数和return

一、 return

1、函数返回值：

a、就是函数返回给调用者的值
b、就是return关键字后面的表达式的值
c、就是函数调用表达式的值

python中每个函数都是有返回值的，返回值就是return后面的值，若没有return，函数返回值就是None。

函数的调用：
a、先回到函数调用的位置
b、用实参给形参赋值（传参）
c、执行函数体
d、执行完函数体，将返回值返回给函数调用表达式
e、回到函数调用的位置
函数的函数体只有在调用后才会调用执行

重点

2、return关键字

a、将return后面的值，返回给函数调用表达式
b、结束函数

3、函数调用表达式：

python每个函数调用表达式的都是有值

#  练习：写一个函数，判断指定的年龄是否属于成年人
def ages(num):
    if num >= 18:
        return '是成年人'
    else:
        return '不是成年人'

age = ages(34)
print(age)
是成年人

4、函数的结束：

a、函数体执行完
b、遇到return

def func2():
    print('123')
    return 10
    print('321')


print(func2())

# 练习：写一个函数，求1+2+3+..和不能大于10000
def sum1():
    num = 0
    for x in range(10001):
        num += x
        if num > 10000:
            num -= x
            return num, x - 1
  # Python函数中可以返回多个值，每个之间用逗号隔开，最后返回的是一个元组

s = sum1(1000)
print(s)
123
10
(9870, 140)

二、作用域

作用域：一个变量可以使用的范围，就是这个变量的作用域
（函数和类可以影响变量的作用域）
Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：
全部变量：从声明开始，到文件结束都可以使用
局部变量：在函数或是类中声明的变量是局部变量。作用域是从声明开始到函数结束。
L （Local） 局部作用域
E （Enclosing） 闭包函数外的函数中
G （Global） 全局作用域
B （Built-in） 内建作用域
以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。

1、全局变量

a = 10  # 这是一个全局变量
print(a)


def func1():
    print(a)


for x in range(3):
    print(a)


for x in range(2):
    b = 100   # 这也是一个全局变量
    print(b)
    print(a)

print('===', b)
10
10
10
10
100
10
100
10
=== 100

2、局部变量

def func3():
    aaa = 100  # 这是一个局部变量
    print(aaa)


func3()
# print(aaa) 会报错 NameError： name: 'aaa' is not defined

3、global 和 nonlocal

global: 在函数中声明一个全局变量
格式：
global 变量名
变量名 = 值

abc = 'abc'  # 全局变量
bcd = 'bcd'


def func4():
    abc = 'aaa'  # 局部变量，如果全局变量和局部变量名相同，
#在函数中使用的是局部变量
    print(abc)
    global bcd  # 说明bcd是一个全局变量
    bcd = 200
    print(bcd)


func4()
print(abc)
print(bcd)

# 练习：声明一个变量，统计一个函数调用的次数
count = 0

def cunt1():
    global count
    count += 1
    print('===')


cunt1()
cunt1()
print('dds')
a = 2
cunt1()
print(count)

"""
nonlocal  在函数中声明函数的时候，才需要使用
"""
def func11():
    a_11 = 10
    print('外部：', a_11)

    # Python中函数里面可以声明函数
    def func12():
        nonlocal a_11
        a_11 = 100
        print('内部：', a_11)
        print('内部函数')

    func12()
    print('外部：', a_11)


func11()

三、匿名函数

匿名函数本质还是函数，以另外一种简单的方式来声明

匿名函数的声明：
函数名 = lambda 参数列表：返回值 --->结果是一个函数变量
lambda :声明匿名函数的关键字

# 写一个函数计算两个数的和
def sum1(x, y):
    return x + y


# 匿名函数
sum2 = lambda x, y: x + y

print(sum1(10, 23))
print(sum2(12, 32))
33
44

四、函数作为变量

1、声明一个函数就是在声明一个变量。函数名可以当成变量使用
可以打印，可以赋值，可以查看类型，可以作为函数的参数。

函数名func1可以当成变量使用

def func1(a):
    print(a)


print(func1, type(func1))
 
#  将函数func1赋给变量a，这个时候a就是一个函数
a = func1
a('sad')
sad
# 将函数func1作为列表的元素
functions = [func1, func1(10)]
functions[0]('sdsasdczxz')
sdsasdczxz
# 1、将函数作为参数
 def my_sum(*numbers):
     sum1 = 0
     for item in numbers:
         sum1 += item
     return sum1

def my_mul(*numbers):
    sum1 = 1
    for item in numbers:
        sum1 *= item
    return sum1

def operation(method, x, y):
    return method(x, y)


result = operation(my_mul, 10, 31)
print(result)
310

Python中三目运算符
值1 if 表达式 else 值2 --->判断表达式是否为true,为True整个表达式的结果值为1，否则值为2.

# 判断10是否大于20
result3 = operation(lambda x, y: x > y, 19, 31)

# 找出两个数中的最大值
result4 = operation(lambda x, y: x if x > y else y, 32, 432)

print(result3, result4)
print('======')
False 432
======
2、将函数作为函数的返回值
#  写一个函数有个参数，要求传入一个运算符号(+ - * < >),返回符号对应的功能

def get_method(func):
    if func == '+':
        return lambda x, y: x + y
    if func == '>':
        return lambda x, y: x > y


result5 = get_method('+')(32, 45)
print(result5)
77
sun = []    
def sss():
    for x in range(5):
        sun.append(lambda y: y*x)  # 此时lambda没有调用
sss()
print(sun[2](2))
print(sun[4](2))
8
8

五、递归函数

1、什么是递归
递归函数：在函数的函数体中，调用函数本身
理论上，循环能做的事情，递归函数也能做

对递归的要求：能不用就不用
函数调用的过程是一个压栈的过程（每调用一次函数，系统都要为其分配内存空间，用来存储函数中声明变量和参数等，这个内存在函数调用结束后会自动销毁）

2、怎么写一个递归函数
a、找临界值（跳出循环 -->return）
b、找关系： 假设当前函数对应的功能已经实现，找到f(n)和f(n-1)的关系
c、使用f(n-1)与前面找到的关系去实现f(n)的功能

#  求1+2+3+4+...+N
#  递归函数
def nums(n):
    # 1、找到临界值
    if n == 1:
        return 1
    #  2、找nums(n)和nums(n-1)的关系：
    """
    nums(n): 1+2+3+...+n-1+n
    nums(n-1):1+2+3+...+n-1
    关系：nums(n) = nums(n-1)+n
    """
# 3、使用nums(n-1)去实现nums(n)的功能
    return nums(n-1)+n


def sum2(n):
    if n == 1 or n == 2:
        return 1
    return sum2(n-1) + sum2(n-2)


print(sum2(5))
5

# 用递归求2*4*6...*n(n是偶数)
def nums(n):
    # 找临界值
    if n == 2:
        return 2
    # 找关系 “f(x) = f(x-2)*2 ”
    return nums(n-2)*n

print(nums(10))
3840
def my_print(n):
    print('*'*n)
    if n == 1:
        return
    return my_print(n-1)

my_print(4)
****
***
**
*
def print_star(n):
    if n == 1:
        print('*')
        return
    print_star(n-1)
    print('*'*n)

print_star(5)
*
**
***
****
*****