函数的使用

###一、复习和补充

####1、函数的声明
def 函数名(参数1，类型1，参数2，类型2，…) –>返回值类型：
函数的描述信息
函数体
补充:参数列表中，可以通过’参数名：类型名’来指定参数的类型，也可以通过设置默认值来说明参数
说明类型的好处：a.传什么类型的值一目了然，b.实现函数体的时候，可以有相关提示
注意：声明函数的时候不会执行函数体

####2、函数的调用
函数名(实参列表)
函数调用过程
第一步：回到函数声明的位置
第二步：用实参给形参赋值 –>传参(保证每个参数都有值)
第三步：执行函数体
第四步：确定返回值 –>将函数调用表达式设置为返回值
第五步：回到函数调用的位置，接着往后执行

####3.函数的参数
位置参数
关键字参数

参数的默认值 –> 有默认值的参数要放在没有默认值参数的后面

补充：不定长参数(面试题)
*参数名:将位置参数作为元组的参数，参数就是一个元组
**参数名:将关键字参数，一参数名为key，实参为值组合为键值对，作为字典的元素，参数是一个字典

注意:经常讲args和kwargs组合在一起使用，但是使用的时候*要昂在**前面！

####4.返回值
python中所有的函数都有返回值，如果遇到return，函数的返回值就是return后面的值；没有遇到返回值就是None

返回值就是函数带哦用表达式的值
调用函数的目的：a.执行函数体 b.获取返回值

return的作用:a.返回返回值 b.结束函数(函数中遇到return结束函数)

###二、匿名函数

####1.普通函数：
def 函数名(参数列表)：
函数体

####2.匿名函数:
函数名 = lambda 参数列表：返回值

说明：
函数名 -> 变量名
lambda -> 关键字
参数列表 -> 参数名1，参数名2…
返回值 -> 相当于只有一个return语句的函数体

匿名函数的调用和普通函数一样：函数名(实参列表)，也支持位置参数，关键字参数，参数设置默认值,不定长参数

1
2
3
4
5
6
7
8
9
# 写一个匿名函数，功能是求两个数的和
sum1 = lambda num1, num2: num1+num2

print(sum1(10, 20))

# 相当于上面的匿名函数
def sum1(num1, num2):
    return num1+num2
print(sum1(10,20))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 练习：读程序
funcs = []
for item in range(1, 5):
    funcs.append(lambda x: x*item)
print(item)
"""
item = 1 -- 4
item=1 [lambda x :x*item]
item=2 [lambda x :x*item,lambda x :x*item]
item=3 [lambda x :x*item,lambda x :x*item,lambda x :x*item]
item=4 [lambda x :x*item,lambda x :x*item,lambda x :x*item,lambda x :x*item]
"""

print(funcs[0](2))   #  8
print(funcs[1](2))   #  8

###三、变量的作用域

####1、变量的作用域
变量的作用域指的是变量能够使用的范围

####2、全局变量
声明在函数和类的外面的变量都是全局变量：作用域是从声明开始，到整个py文件结束(任何地方都可以使用)

####3.局部变量
声明在函数和类中的变量都是局部变量，声明在函数的局部变量，作用域是从声明开始到真个函数结束

####4.global关键字
在函数中说明一个变量是全局变量

注意：只能在函数中使用

1
2
3
4
5
6
7
8
9
10
11
# 全局变量
name = 'abc'
def func2():
    global age         # 说明age是一个全局变量
    age = 18
    global name        # 说明当前函数中使用的那么是全局变量name
    name = 'aaa'
    print(name)
func2()
print(name)
print(age)

####5.nonlocal关键字
想要在局部的局部中修改局部变量的值

1
2
3
4
5
6
7
8
9
10
def func3():
    abc = 100
    def func4():
        nonlocal abc
        abc = 200
        print('f4:', abc)     #   f4: 200

    func4()
    print('f3a;', abc)    #  f3a; 200
func3()

###四、函数作为变量
声明函数就是声明一个类型是function的变量，函数名实质就是变量名

####1.变量可以给其他变量赋值

1
2
3
4
5
# 声明一个func1，类型是function
func1 = lambda x: print(x)
# 用一个变量给变量func2赋值，func2也是一个函数
func2 = func1
func2(10)

####2、函数作为列表的元素

1
2
3
4
5
6
7
8
9
10
def func22():
    print('我是函数')
    return 10
list2 = [1, func22, func22()]
print(list2)
print(func22())
# list2[1]渠道的是一个函数，通过后面加()调用函数
print(list2[1]())   # print(func22())
# list2[2]取到的是整数10
print(list2[2]+100)

####3、将函数作为列表

1
2
3
4
5
6
7
def func11(n):
    # n = func12
    n()  # func12()
def func12():
    print('hello,world')

func11(func12)

####4、应用：sort的使用
a.列表。sort(key=None, reverse=False)
b.使用sort的时候，可以通过给key一个函数变量，来规定列表中的元素按照什么标准来进行排序
c.这儿的函数变量要求要有一个参数和一个返回值。参数代表列表中的元素，返回值代表按照那个标准排序

####5、将函数作为返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 根据运算符符号，返回对应的功能
def operation(operator:str):
    if operator == '+':
        def func1(*args, **kwargs):
            sum1 = 0
            for item in args:
                sum1 += item
            for key in kwargs:
                sum1 += kwargs[key]
            return sum1
        return  func1
f1 = operation('+')  # f1就是两个不定长参数，功能是求和的函数
re = f1(10, 20, a=2, b=3)
print(re)  # 35
# print(operation('+')(10, 20, a=2, b=3))  # 35

###五、函数的调用

####1.补充：python中的函数可以有多个返回值

1
2
3
4
5
6
7
# 求多个函数的和以及平均值
def yt_sum(*nums):
    sum1 =sum(nums)
    average = sum1 / len(nums)
    return sum1, average    # 同时返回和、平均值
a, b = yt_sum(2, 45, 58, 24, 68, 34)
print(a,b)  #  231 38.5

####2.函数的调用过程是一个压栈的过程

每次调用函数的时候，系统都会在内存中(栈)开辟空间来存储函数执行过程产生数据(函数中声明的变量)
当函数盗用完成后，这块内存会自动销毁。

###六\递归函数

####1.什么是递归函数
递归函数：函数中调用本身，这样的函数就是递归函数(自己调用自己）

循环能做的事情递归都可以做，但是实际上循环能解决的问题绝对不选递归

####2.怎么写递归函数
第一步：确定临界值(循环结束的条件)，让函数结束
第二步：找关系，假设函数的功能已经实现，找f(n)和f(n-1)的关系
第三步：根据关系，用f(n-1)实现f（n)的功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 写一个递归函数，实现1+2+3+...+n
def yt_sum(n):
    # 1.找临界值
    if n == 1:
        return 1
    # 2.找关系
    """
    yt_sum(n)=1+2+3+...+n
    yt_sum(n-1)=1+2+3+4+...+n-1
    yt_sum(n)=yt_sum(n-1)+n
    """
    # 用f(n-1)实现f(n)的功能
    return  yt_sum(n-1)+n
print(yt_sum(5))   # 15
#步骤：
"""
yt_sum(5) n=5 5!=1 return yt_sum(4)+5
yt_sum(4) n=4 4!=1 return yt_sum(3)+4
yt_sum(3) n=3 3!=1 return yt_sum(2)+3
yt_sum(2) n=2 2!=1 return yt_sum(1)+2
yt_sum(1) n=1 1==1 return 1
"""

总结：递归，能不用就不用

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

1
2
3
4
5
6
7
def ni_xu(list1:list):
    list2 = []
    for item in list1[::-1]:
        list2.append(item)
    return list2
list1=[1,2,3,4,5]
print(ni_xu(list1))  # [5, 4, 3, 2, 1]

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

1
2
3
4
5
6
7
def extract(str1:str):
    str2 = ''
    for item in range(0, len(str1), 2):
        str2 += str1[item]
    return str2
str1 = 'abcdefghijk'
print(extract(str1))

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

1
2
year = lambda n: bool(n%4 == 0 and n%100 != 0)
print(year(2008))

4.使用递归打印:

1
2
3
4
5
6
7
8
9
10
11
12
### n = 3的时候
###
####
###     @
###   @ @ @
### @ @ @ @ @
### n = 4 的时候:
###      @
###    @ @ @
###  @ @ @ @ @
### @ @ @ @ @ @ @
###

1
2
3
4
5
6
7
8
9
10
11
12
13
def print1(n, m=0):
    a = "@"
    if n == 0:
        return
    print1(n - 1, m + 1)
    print(' ' * m, end='')
    print((a + '@' * (n - 1) * 2))
print1(4)

#    @
#   @@@
#  @@@@@
# @@@@@@@

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

1,1,2,3,5,8,13,21,34,55

1
2
3
4
5
6
def series(n=10):
    if n == 1 or n == 2:
        return 1
    return series(n-1) + series(n-2)
print(series())     # 55
print(series(11))   # 89

6.写一个函数，获取列表中的成绩的平均值，和最高分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def xw_list(list1):
    sum1 = 0
    ave = 0
    max1 = list1[0]
    for item in list1:
        sum1 += item
        ave = (sum1/len(list1))
        if max1 <list1[0]:
            break
        else:
            max1 = item

    return sum1, ave,max1
list1=[1,2,3,4,5,6,7,8,9]
print(xw_list(list1))   # (45, 5.0, 9)

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

1
2
3
4
5
6
7
def xw_list(list1):
    list2 = []
    for item in list1[::2]:
        list2.append(item)
    return list2
list3=['a','b','c', 'd','e','f']
print(xw_list(list3))   # ['a', 'c', 'e']

8.实现属于自己的字典update方法：用一个字典去更新另一个字典的元素(不能使用自带的update方法)

yt_update(字典1， 字典2)

1
2
3
4
5
6
7
8
def xw_update(dict1,dict2):
    for key in dict1:
        dict2[key] = dict1[key]
    return dict2

dict1 = {'name1': '小明', 'age1': 22, 'score1': 88}
dict2 = {'name2': '小红', 'age2': 20, 'score2': 95}
print(xw_update(dict1, dict2))   # {'name2': '小红', 'age2': 20, 'score2': 95, 'name1': '小明', 'age1': 22, 'score1': 88}

9.实现属于自己的items方法：将字典转换成列表，字典中的键值对转换成元祖。（不能使用items方法）

yt_items(字典)

例如：{‘a’: 1, ‘b’: 2, ‘c’: 3} - –> [(‘a’, 1), (‘b’, 2), (‘c’, 3)]

1
2
3
4
5
6
7
def xw_list(dict1):
    list1 = []
    for item in dict1:
        tuple1 = item, dict1[item]
        list1.append(tuple1)
    return list1
print(xw_list({'a':1,'b':2,'c':3,'d':4}))   # [('a', 1), ('b', 2), ('c', 3), ('d', 4)]