函数的返回值

1. 函数的返回值:

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

python每个函数都有返回值,返回值就是return后面的值,如果没有返回值,那么返回值就是None

1. return关键字

• a.将return后面的值返回给表达式
• b.结束函数

2. 函数调用表达式:

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

def fun1():
    print('aaa')


a = fun1()  # 函数调用表达式
print(a, fun1())


def fun2(x, y):
    print('bbb')
    return x + y


num = fun2(1, 3)
print(fun2(1, 5))

case: 写个函数,判断指定的年龄是否属于成年人,返回结果

def isAdult(n):
    
    :type n: int
    :rtype: bool
    
    if n >= 18:
        return True
    return False


if isAdult(20):
    print('成年')
else:
    print('未成年')

3. 函数的结束

• a.函数体执行完
• b.遇到return

def fun3():
    print('123')
    return 1
    print('666')


fun3()

case:写一个函数,下载指定地址敌营的数据

def download(url):
    判断是否有网络
    if 没有网:
        return None
    网络请求
    请求数据
    保存数据

case: 一个函数 求1+2+3+...,和不能大于10000

def getSum():
    i = 0
    sum1 = 0
    while True:
        if sum1 + i >= 10000:  # 如果sum1 下一次加上i大于10000,则返回 i-1
            return i - 1, sum1  # python中函数可以有多个返回值,用逗号隔开,以元组类型返回
        sum1 += i
        i += 1


print(getSum())

函数的作用域

• 作用域:一个变量可以使用的范围,就是这个变量的作用域(函数和类可以影响变量的作用域)
• 全局变量:从声明开始,到文件结束都可以使用
• 局部变量:在函数(类)中声明的变量是局部变量.作用域是声明开始到函数结束

1.全局变量

a = 10  # 全局变量
print(a)
def fun1(a):
    print(a)
for _ in range(3):
    b = 20  # 全局变量
    print(a)
print(b)
def fun2():
    print(b)
fun2()

2.局部变量

def fun3():
    aaa = 2  # 局部变量
# print(aaa)  # 不可调用,报错 NameError: name 'aaa' is not defined

3.global / nonlocal

• global: 在函数中创建全局变量或者声明使用的是全局变量
• 格式:

global 变量名
变量名 = value

abc = 'abc'  # 全局变量
bbb  = 'bbb'
def fun4():
    abc = 'aaa'  # 声明了一个局部变量叫abc,不会互相影响,函数体内优先使用局部变量
    global bbb  # 声明使用全局变量 bbb  如果前面没有声明则新声明一个
    bbb = 100
    print(abc, bbb)
fun4()
print(abc, bbb)

case: 声明一个变量统计函数调用的次数

# global
count = 0
def fun5():
    global count
    count += 1

fun5()
fun5()
print(count)

# nonlocal

def fun6():
    a1 = 10
    print(a1)
    # python中函数里面可以声明函数  只能在该函数体中调用 外部无法调用
    def fun61():
        nonlocal a1
        a1 = 100
        print('333')
    fun61()
    print(a1)
fun6()

匿名函数

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

函数名 = lambda 参数列表 : 返回值  →  结果是一个函数变量

• lambda: 声明匿名函数的关键字

case: 写一个函数计算两个数的和

def sum1(x, y):
    return x + y
print(sum1(3, 6))
sum2 = lambda x, y: x + y
print(sum2(6, 3))

函数变量

声明一个函数就是再声明一个变量.函数名可以当成变量来使用,可以打印 可以赋值/查看类型/作为参数/作为返回值

a = 'a'
print(a)


# 函数名fun1可以当成变量使用
def fun1(a):
    print(a)
    return 10


print(fun1, type(fun1))

# 将函数fun1赋给变量a,这个时候a就是一个函数
a = fun1
b = fun1(10) + 100
a('aaa')
# 将函数fun1作为列表的元素
fun2 = [fun1]
fun2[0]('aaaa')

1.将函数作为参数

def getSum(num):
    sum1 = 0
    for i in num:
        sum1 += i
    return sum1


def getMul(*num):
    mul = 1
    for i in num:
        mul *= i
    return mul


def operation(method, *num):
    return method(num)

相当于三目运算符

• 值1 if 条件 else 值2 → 判断表达式是否为true,为true整个表达式的结果是'值1',否则是'值2'

res = operation(getSum, 1, 2, 3, 4, 5, 6)
# 判断10是否大于20
# res = operation(lambda x, y: x > y, 10, 20)
# 判断两个数谁大
# res = operation(lambda x, y: x if x > y else y, 10, 20)
print(res)

3.将函数作为函数的返回值

case: 一个函数有个参数,要求传入一个运算符号(+,-,*,/,<,>),返回符号对应的功能 + → 求和功能

def getMethod(char):
    if char == '+':
        return lambda x, y: x + y
    elif char == '-':
        return lambda x, y: x - y
    elif char == '*':
        return lambda x, y: x * y
    elif char == '/':
        return lambda x, y: x / y
    elif char == '<':

        def fun(x, y):
            return x < y

        return fun
    elif char == '>':

        def fun(x, y):
            return x > y

        return fun

    else:
        def fun(*num):
            return None
        return fun


print(getMethod('-')(10, 20))
print(getMethod('+')(10, 20))
print(getMethod('*')(10, 20))
print(getMethod('/')(10, 20))
print(getMethod('<')(10, 20))
print(getMethod('>')(10, 20))
print(getMethod('?')(10, 20))

递归

1.什么是递归

• 递归函数:在函数体中调用函数本身
• 一切循环皆可递归
• 对递归的要求:能不用就不用
• 函数调用的过程是一个压栈的过程(每调用一次函数,系统都要为其分配内存空间,用来存储函数中声明的变量和参数等,这个内存再函数调用结束后会自动销毁)

2.怎么写递归函数

• a.找出临界值(跳出递归 → return)
• b.找关系:假设当前函数对应的功能已经实现,找到f(n)和f(n-1)的关系
• c.使用f(n-1)与f(n)的关系来实现f(n)的功能

# 递归示例

def fun1():
    fun1()


fun1()

case: 写一个递归实现1+2+3...+n

def getSum(n):
    if n == 1:
        return 1
    else:
        return getSum(n - 1) + n


print(getSum(10))
'''
getSum(n)
getSum(5): getSUm(4) + 5
getSum(4): getSUm(3) + 4
getSum(3): getSUm(2) + 3
getSum(2): getSUm(1) + 2
getSum(1): return 1
'''

case: 递归求246...n(n是偶数)

def getMul(n):
    if not n % 2:
        if n == 2:
            return 2
        else:
            return getMul(n - 2) * n


print(getMul(5))

case: 递归实现以下

'''
n = 3
***
**
*
n = 4 
****
***
**
*
'''


def printStar(a):
    if a == 1:
        print('*')
        return 0
    else:
        print('*'*a)
        printStar(a-1)


# printStar(3)

def printStar2(a):
    if a == 1:
        print('*')
        return 0
    else:
        printStar2(a-1)
        print('*'*a)


printStar2(3)

作业

1.写⼀个函数将⼀个指定的列表中的元素逆序(例如[1, 2, 3] -> [3, 2, 1])(注意：不要使⽤列表⾃带的逆序函数)

def backdrop(list1):
    list2 = []
    for i in range(0 - len(list1), 0):
        list2.append(list1[i])
    return list2

2.写⼀个函数，提取出字符串中所有奇数位上的字符

def getOddAlpht(str1):
    str2 = 2
    for i in range(len(str1)):
        if i % 2:
            str2 += str1[i]
    return str2

3.写⼀个匿名函数，判断指定的年是否是闰年

a = lambda n: bool(((not n % 4) and (n % 100))or(not n % 400))
print(lambda n: bool(((not n % 4) and (n % 100))or(not n % 400))(2011))

4.使⽤递归打印：

1.png

def printSign(n, space=0):

    '''
    :type n:int
    :type space:int
    :rtype:None
    print(' ' * ? + '@' * (2 * n - 1))
    n = 5 时
    print(' ' * 0 + '@' * (2 * 5 - 1))
    print(' ' * 1 + '@' * (2 * 4 - 1))
    print(' ' * 2 + '@' * (2 * 3 - 1))
    print(' ' * 3 + '@' * (2 * 2 - 1))
    print(' ' * 4 + '@' * (2 * 1 - 1))
    所以考虑增加一个默认值为0的参数
    '''
    if n == 1:
        print(' ' * (space) + '@' * (2 * n - 1))
    else:
        printSign(n - 1, space + 1)
        print(' ' * (space) + '@' * (2 * n - 1))


printSign(3)

5.写函数，检查传⼊列表的⻓度，如果⼤于2，那么仅保留前两个⻓度的内容，并将新内容返回给调⽤者。

def getBoth(list1):
    '''
    :type list1:list
    :rtype:list
    '''
    if len(list1) <= 2:
        return list1
    else:
        del list1[len(list1) - 1]
        getBoth(list1)
        return list1


print(getBoth([1, 2, 3, 4, 5, 6]))

6.写函数，利⽤递归获取斐波那契数列中的第 10 个数，并将该值返回给调⽤者。

def getFibonacci10th(n1=1, n2=0, count=0):
    '''
    rtype:int
    1       1       n1 = 1  n2 = 0  fn = n1+n2
    2       1       n1 = n2 n2 = fn fn = n1+n2
    3       2       n1 = n2 n2 = fn fn = n1+n2
    4       3       n1 = n2 n2 = fn fn = n1+n2
    5       5       n1 = n2 n2 = fn fn = n1+n2
    6       8       n1 = n2 n2 = fn fn = n1+n2
    7       13      n1 = n2 n2 = fn fn = n1+n2
    8       21      n1 = n2 n2 = fn fn = n1+n2
    9       34      n1 = n2 n2 = fn fn = n1+n2
    10      55      n1 = n2 n2 = fn fn = n1+n2
    '''
    if count == 9:
        n1 = 1
        n2 = 0
        fn = n1 + n2
        return n1, n2, fn
    else:
        count += 1
        n1, n2, fn = getFibonacci10th(n1, n2, count)
        n1 = n2
        n2 = fn
        fn = n1 + n2
        return n1, n2, fn


_, _, fn = getFibonacci10th()
print(fn)

7.写⼀个函数，获取列表中的成绩的平均值，和最⾼分

"""递归版调试中
def getScore(list2, i=0):
    '''
    0       4
    1       5
    2       6
    3       1
    4       2
    5       3
    '''
    max1 = list2[0]
    if i == len(list2) - 1:
        return list2[i]
    else:
        sum1 = 0
        i += 1
        if max1 > list2[i]:
            max1 = list2[i]
        sum1 += getScore(list2, i)
        return sum1 / len(list2), max1


avg, max1 = getScore([4, 5, 6, 1, 2, 3])
"""


def getScore(list2):
    max1 = list2[0]
    sum1 = 0
    for i in list2:
        sum1 += i
        if max1 < i:
            max1 = i
    return max1, sum1 / len(list2)


max1, avg = getScore([4, 5, 6, 1, 2, 3])
print('平均值:', avg, '最大值:', max1)

8.写函数，检查获取传⼊列表或元组对象的所有奇数位索引对应的元素，并将其作为新的列表返回给调用者

def getNewList(kwargs):
'''
:type kwargs:tuple/list
:rtype:list
'''
    list3 = []
    for index in range(len(kwargs)):
        if index % 2:
            list3.append(kwargs[index])
    return list3


print(getNewList([1, 2, 3, 4, 5, 6]))