转载请注明预见才能遇见的博客：http://my.youkuaiyun.com/
原文地址：https://blog.youkuaiyun.com/pcaxb/article/details/91980353
人工智能系列-Python系列（五）函数详解
目录
7.nonlocal，指定上一级变量，如果没有就继续往上直到找到为止
9.递归：在函数内部，可以调用其他函数。如果在调用一个函数的过程中直接或间接调用自身本身
14.filter 过滤 filter(处理逻辑，可迭代对象) 如果处理逻辑是true就是保留下来
1.函数的定义
# 函数：函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。
# 过程：就是没有返回值的函数
# 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
# 面向对象：对函数进行分类和封装，让开发“更快更好更强...”
# 面向过程编程：根据业务逻辑从上到下实现功能，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制
2.函数的使用
# def 函数名(参数):
# ...
# 函数体
# ...
# 返回值# 函数的定义主要有如下要点：
# def：表示函数的关键字
# 函数名：函数的名称，日后根据函数名调用函数
# 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
# 参数：为函数体提供数据
# 返回值：当函数执行完毕后，可以给调用者返回数据。3.函数的返回值
# 1)0 没有返回值，就是返回None
# 2)1 返回的就是对象
# 3)>1 返回的就是元组4.参数
1）形参和实参
name 叫做函数func的形式参数，简称：形参、不占内存
# def func(name):
# print name
# 'wupeiqi' 叫做函数func的实际参数，简称：实参
# func('wupeiqi')2）位置参数和关键字参数
# def test(x,y,z):#x=1,y=2,z=3
# print(x)
# print(y)
# print(z)
# 位置参数，必须一一对应，缺一不行多一也不行
# test(1,2,3)
# 关键字参数，无须一一对应，缺一不行多一也不行
# test(y=1,x=3,z=4)
# 位置参数必须在关键字参数左边
# test(1,y=2,3)#报错
# test(1,3,y=2)#报错
# test(1,3,z=2)
# test(1,3,z=2,y=4)#报错
# test(z=2,1,3)#报错
# 默认值参数
# def test(x, y=2):
# print(x, y)
#
# test(1) # 1 2
# test(1, 3) # 1 3
# test(x=3, y=5) # 3 5
# test(3, y=8) # 3 8
# test(x=3,8) # 错误
5.参数组 *列表 **字典
1）单个测试
# def test01(x, *args):
# print(x, args)
#
# test01(1) # 1 ()
# test01(1, 2) # 1 (2,)
# test01(1, 2, 4, 4, 5, 5, 6) # 1 (2, 4, 4, 5, 5, 6)
# test01(1, {"name": "pca"}) # 1 ({'name': 'pca'},)
# test01(1, [1, 2, 4]) # 1 ([1, 2, 4],)
# test01(1, *[1, 1, 2, 2]) # 1 (1, 1, 2, 2)
# test01(1, *(1, 2, 4)) # 1 (1, 2, 4)
# # test01(1,y=2,z=3) # 错误
# def test02(x, **kwags):
# print(x, kwags)
#
# test02(1,y=2,z=3) # 1 {'y': 2, 'z': 3}
# # test02(1,y=2,z=3,z=3)#会报错 ：一个参数不能传两个值
# # test02(1,1,1,1,y=2,z=3)#会报错2）组合测试
# def test03(x,*args,**kwargs):
# print(x)
# print(args,args[-1])
# print(kwargs,kwargs.get('y'))
# test03(1,1,2,1,1,11,1,x=1,y=2,z=3) #报错
# test03(1,1,2,1,1,11,1,y=2,z=3)
# test03(1,*[1,2,3],**{'y':1})5.全局变量和局部变量
# 在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
# 全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
# 当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。# name = "lili"
# # def pn():
# # global name # 这样可以吧name变成全局的，global一定要放到对应变量上面，推荐所有的global都放到函数顶部
# # name = 111 # 加了global 之后，这里修改的就是全局的
# # print(name) # 111
# # # print(name) #lili
# # print(name) # 111
# # pn()6.全局变量变量名大写，局部变量变量名小写
略
7.nonlocal，指定上一级变量，如果没有就继续往上直到找到为止
# name = "11"
# def weihou():
# name = "22"
# def weiweihou():
# nonlocal name # nonlocal，指定上一级变量，如果没有就继续往上直到找到为止
# name = "33"
# weiweihou()
# print(name)
# print(name)
# weihou()
# print(name)
# 11
# 33
# 118.前向引用，函数即变量
略
9.递归：在函数内部，可以调用其他函数。如果在调用一个函数的过程中直接或间接调用自身本身
# 递归特性:
# 1). 必须有一个明确的结束条件，函数的终止使用return
# 2). 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
# 3). 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，
# 每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，
# 所以，递归调用的次数过多，会导致栈溢出）# def calc(n):
# # print(n)
# if int(n / 2) == 0:
# return n
# res = calc(int(n / 2))
# return res
#
#
# res = calc(10)
# print(res)
# import time
# def sleep1(x):
# time.sleep(1)
# print(x)
# x -= 1
# if x >= 0:
# sleep1(x)
# sleep1(10)10.函数作用域
# 函数的作用域只跟函数声明时定义的作用域有关，跟函数的调用位置无任何关系
# name = 'alex'
# def foo():
# name = 'linhaifeng'
# def bar():
# # name='wupeiqi'
# print(name)
# return bar
# a = foo()
# print(a)
# a() # bar() linhaifeng
#
# foo()() # linhaifeng11.匿名函数
# lambda x: x + 1
#
# func = lambda x, y, z: x + y + z
# print(func(1, 2, 3)) # 612.函数式编程
# 编程的方法：面向过程，函数式，面向对象
# 面向过程：
# 函数式：数学意义的函数 + 编程语言定义的函数
# 高阶函数 (满足下面一个条件就是高阶函数)
# 1)把函数当作参数传给另外一个函数
# 2)返回值中包含函数13.map(处理逻辑，可迭代对象) 对可迭代对象做处理
# msg = 'linhaifeng'
# print(list(map(lambda x: x.upper(), msg))) # ['L', 'I', 'N', 'H', 'A', 'I', 'F', 'E', 'N', 'G']
#
# arr01 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# print(list(map(lambda x: x * 10, arr01))) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
14.filter 过滤 filter(处理逻辑，可迭代对象) 如果处理逻辑是true就是保留下来
# movie_people = ['alex', 'wupeiqi', 'yuanhao', 'sb_alex', 'sb_wupeiqi', 'sb_yuanhaosb']
# print(list(filter(lambda n: n.endswith('sb'), movie_people))) # ['sb_yuanhaosb']
# print(list(
# filter(lambda n: not n.endswith('sb'), movie_people)))
# # ['alex', 'wupeiqi', 'yuanhao', 'sb_alex', 'sb_wupeiqi']
15.reduce
# from functools import reduce
# num_l = [1, 2, 3, 100]
# print(reduce(lambda x, y: x + y, num_l, 1)) # 107
# print(reduce(lambda x, y: x + y, num_l)) # 106
#
# print(reduce(lambda x, y: x * y, num_l, 1)) # 600
# 1*1 * 2 * 3 * 100 = 600 默认值是1，然后默认值 * 可迭代对象的第一个值，然后结果 * 第二个值，然后结果 * 第三个值
16.内置函数
# 序列：列表、元组、字符串# 参考资料：
# https://docs.python.org/zh-cn/3/library/functions.html
# https://www.cnblogs.com/xiao1/p/5856890.html
# https://www.cnblogs.com/linux-chenyang/p/6473820.html1).zip
# person = {'name': 'pca', 'age': 123}
# zipRes = zip(person.keys(), person.values())
# print(list(zipRes)) # [('name', 'pca'), ('age', 123)]2).max min
# 说明：不同类型之间不能比较# nums = [1, 3, 100, -1, 2]
# print(max(nums)) # 100
# print(min(nums)) # -1
age_dic = {'alex_age': 18, 'wupei_age': 20, 'zsc_age': 100, 'lhf_age': 30}
print(max(age_dic.values())) # 100
print(max(age_dic.keys())) # zsc_age# 需求：取出key和value
print(list(zip(age_dic.values(), age_dic.keys())))
# [(18, 'alex_age'), (20, 'wupei_age'), (100, 'zsc_age'), (30, 'lhf_age')]
print(max(zip(age_dic.values(), age_dic.keys()))) # (100, 'zsc_age')# 需求：取出age最大的那个对象people = [
{'name': 'alex', 'age': 1000},
{'name': 'wupei', 'age': 10000},
{'name': 'yuanhao', 'age': 9000},
{'name': 'linhaifeng', 'age': 18},
]
# 通过取出某个属性去比较
print(max(people, key=lambda p: p['age'])) # {'name': 'wupei', 'age': 10000}
参考资料：https://www.cnblogs.com/linhaifeng/articles/6113086.html人工智能系列-Python系列（五）函数详解
博客地址：https://blog.youkuaiyun.com/pcaxb/article/details/91980353
扫一扫
2997
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
