目录
第一节：
函数可简单分为以下：
1.无参数
2.带可变参数
3.带默认值参数
4.带返回值
定义一个函数：
def? 函数名(可选择参数):
? ? ? ? ? ?函数体
一个简单函数的使用：? ?(无参数)
def jsy(): # 将函数加载到内存空间
print('jsy')
jsy() # 调用函数输出：
jsy没有参数时，函数就相当于一个具体功能的实现。
带参数的函数:
该代码为求 1~n 的总和
#求 1~n 的总和
def sum(i):
a = 1
s = 0
for j in range(i):
s += a
a += 1
print('1~{}的总和是{}'.format(i,s))
sum(5)输出：
1~5的总和是15
所谓可变参数是指在定义函数时，参数为可变的变量，当使用该函数时需要在括号里加上传入的变量
带默认值参数的函数：
1.在定义函数的时候，有一个或多个参数已经赋好值了，默认了参数的值
2.默认设置好的参数可以不写，当然写上会覆盖默认参数值
3.在定义函数的时候，普通参数要在默认值参数的前面
4.默认参数的顺序是固定的，可通过指明关键字参数来赋值，通过该方式可改变赋值顺序
下面举例说明：
def borrow_book(username, bookname, number=1, school='北大'):
print('进入{}的借书系统...'.format(school))
print('{}已借{}，借阅{}本'.format(username, bookname, number))
borrow_book('jsy', '狂人日记') #对于默认值参数可默认赋值，可以不手动赋值
borrow_book('jsy', '大主宰', 6) #要改变默认值参数值时，需要按顺序给它的参数重新赋值
borrow_book('jsy',bookname= '朝花夕拾', school='清华') #指明关键字参数来赋值，非默认参数也可使用输出：
进入北大的借书系统...
jsy已借狂人日记，借阅1本
进入北大的借书系统...
jsy已借大主宰，借阅6本
进入清华的借书系统...
jsy已借朝花夕拾，借阅1本当参数的数据类型是列表：
把实参的地址传入形参，函数内部也可对外部的list直接修改(下文中我们会提到可变和不可变类型)
library = ['高数', '政治', '英语', '计算机组成和原理']
def add_book(bookname): # 形参
library.append(bookname)
print('添加成功！')
def show_book(books): # 遍历时相当于传入library的地址
for book in books:
print(book)
add_book('数据结构') # 实参
show_book(library) # 实参输出：
添加成功！
高数
政治
英语
计算机组成和原理
数据结构带可变参数的函数(装包和拆包):
可变参数可理解为传入参数的数目和类型可以变化，而在使用可变参数时就会出现装包和拆包的动作。
可变参数可分为：
*args （arguments）默认为一个容器，多个参数，缺省参数在*args的后面
**kwargs （keywardarguments）关键字参数多个可变参数? *args：
当*args使用时，可以改变*后的参数名；作用于单个元素
在函数中的装包，以元组输出
def get_(*a): # 可写入多个参数
print(a) # 以元组形式输出
get_(1)
get_(1, 2, 3, 4)
输出：
(1,)
(1, 2, 3, 4)*也可以在普通赋值时使用：
a, *b, c = 1, 2, 3, 4, 5
print(a, b, c) # a和c只能赋一个值，而b可以列表形式存放多值输出：
1 [2, 3, 4] 5
此时，由于*的使用出现了装包的现象
可变参数? **kwargs：
需要注意它的传值方式；作用于关键字参数(键值对)
如果说 * 是对列表，元组，集合进行装包拆包的操作，那么 ** 就是对字典的装包拆包操作
def show_book(**kwargs):
print(kwargs) # 打印为字典
for k, v in kwargs.items():
print(k, v)
show_book() #无参数输出字典，说明**在字典层面进行操作
show_book(bookname='墨菲定律', author='鸿雁') # 仅以键值对的形式赋值，加到字典中
# 一颗星*是拆元组列表集合的包，两颗星**是拆字典的包
book = {'book': '红楼梦', 'author': '曹雪芹'}
show_book(**book) #很明显，这是一个拆包操作输出：
{}
{'bookname': '墨菲定律', 'author': '鸿雁'}
bookname 墨菲定律
author 鸿雁
book 红楼梦
author 曹雪芹当 * 和 ** 同时存在：
此时传入参数也是要按照参数顺序进行传值
def show_(*args, **kwargs): #装包到kwargs
print(args)
print(kwargs)
book = {'book': '红楼梦', 'author': '曹雪芹'}
show_('jsy', 'JJ', **book) #book拆包；也可以看出来**只接受字典
输出：
('jsy', 'JJ')
{'book': '红楼梦', 'author': '曹雪芹'}装包和拆包：
该过程便可理解为一次装包
a, b = (1, 2)
print(a, b)在下面代码例子中，拆包是指在给函数传入的参数是列表或是集合，元组时，想要传入其中的元素，所以要将其拆开，故需在名称前加上*
装包时，是由于传入参数的数目是变化的，不固定的，要将其打包作为元组整体传入，然后在函数内部对元组进行操作
ran_list = [23, 4, 5, 47, 85, 96, 1, 0] # 需要先进行拆包
def get_sum(*args): #再进行装包
print(args)
s = 0
for i in args:
s += i
print('和：', s)
get_sum(*ran_list) # 自动拆包输出：
(23, 4, 5, 47, 85, 96, 1, 0)
和： 261带返回值的函数：
参数：外界向函数传值
返回值：函数内容向外界传达，停止函数的调用，立刻结束函数并返回值? ? ??
return
1.若一个函数有返回值，需要接收
2.当返回多个值时，为元组形式
3.当函数没有返回值时，返回None
下面举一个用函数实现冒泡排序的例子：
将列表元素从小到大进行排序，并返回最小值和最大值
def get_sort(number):
# 排序：冒泡排序
for i in range(0, len(number) - 1):
for j in range(0, len(number) - 1 - i):
if number[j] > number[j + 1]:
number[j], number[j + 1] = number[j + 1], number[j]
# 获取头，尾
min = number[0]
max = number[-1]
# 返回
return min, max # 返回多个值时，为元组形式
list1 = [21, 11, 25, 69, 96, 12, 1, 10, 20]
print(get_sort(list1))输出：
[1, 10, 11, 12, 20, 21, 25, 69, 96]
(1, 96)第二节：
全局变量和局部变量：
通俗的讲，函数外部定义的变量可称为全局变量，函数内部定义的变量可称为局部变量
1.局部变量在函数被调用时创建内存空间，在函数完成后被回收
2.查看局部变量使用locals()
3.查看全局变量使用globals()
优先级问题：当函数里想要使用变量a， 如果函数里面没有a，则使用全局变量a
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 如果函数里定义了a，则(优先)使用局部变量a
Python搜索变量或是函数优先级：局部变量--->全局变量--->builtins
?
举例说明：
# 函数里有a ，优先找内部a
# 全局变量
a = 100
def test1():
# 局部变量
a = 0
print('a = ', a) # 函数里有a ，优先找内部a
test1() #调用函数此时输出的是局部变量a：
a = 0
# 函数里没有a，则使用全局变量a
a = 100
def test2():
b = 2
print('a = ', a) # 函数里没有a，则使用全局变量a
print('b = ', b)
test2()此时输出全局变量a：
a = 100
b = 2可变和不可变类型：
不可变：当改变变量的值时，地址也发生了改变 （int str float tuple）
可变：当改变变量的值时，地址没有发生改变? ? ?（bool? list? set? 字典）
全局变量可以在函数内调用，但是想要修改全局变量的值，要看它是可变还是不可变类型
如果变量是不可变类型：则需 global 关键字声明，才可修改。
如果变量是可变类型：则可以直接修改，不用加global。
用global改变 int 类型的全局变量：
a = 100
def test3():
# 改变全局变量a的值
global a
a = 0 #在全局上，a的值变为0
print('a = ',a)
test3()输出：
a = 0对于可变类型在函数里可进行修改：
library = ['红楼梦','西游记','三国演义']
def add_book(bookname):
if bookname not in library:
library.append(bookname)
else:
print('已经存在该书！')
def show_book():
for book in library:
print(book)
add_book('墨菲定律')
show_book()对于列表，可以在函数里直接用append()进行添加元素。
输出：
红楼梦
西游记
三国演义
墨菲定律变量作用域（LEGB）：
L:local? ? ? ? ? ?本地(内部函数)
E:enclosing? ?嵌套(外部函数)
G:global? ? ? ? 全局
B:built-in? ? ? ? 系统内置的
第三节：
函数注释问题：
需要注意的是，对自己写的函数进行适当的注释，有助于其他人的阅读理解，并且可能也是以后的工作要求，所以养成代码注释，函数注释的习惯也是相当的重要。
所谓函数注释，是在函数体里写的注释，而且需要按照一定的格式去写，格式的话，可以CTRL+左键，进入系统函数的builtins去参照。
大致格式：
def 函数名(username,password,...)
'''
函数的说明：
参数说明：
:param username:
:param password:
返回值说明：
:return:
'''
函数引用：
sys.getrefcount()? ? 获取一块空间地址引用次数? ? ? ? ? ? ?
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?del? 可用来删除，且删除后减少了一次引用
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?使用该函数时，引用次数会默认+1
import sys
list1 = [1, 2, 3, 4, 5, 6]
list2 = list1
list3 = list1
print(sys.getrefcount(list1))
del list3 # 删去list3时，引用次数为3
print(sys.getrefcount(list1))
输出：
4
3使用sys.getrefcount函数 ，也是对list1的一次引用，故第一次输出为4次
函数参数引用：
1.函数参数是传递引用，也就是数据的内存地址
2.必须要分清传递的值是可变类型还是不可变类型
可变：函数里面改变，外部全局变量也改变
不可变：函数里面改变，外部不改变
函数嵌套：
nonlocal? ? 在闭包内修改或使用外部函数变量
global? ? ? ? 修改或使用全局变量
?举例说明：
def outer():
a = 100 # 变量
def inner(): # 相当于变量
b = 200
nonlocal a
a += b # 内部函数不能修改外部函数变量，想要修改需要加关键字nonlocal
print('我是内部函数inner', b)
result = locals() # locals()表示查看函数中的局部变量
print(result)
print(a)
inner()
print(a) # 调用inner后，a的值发生改变
outer()
输出：
{'inner': <function outer.<locals>.inner at 0x000001E4A09BA550>, 'a': 100}
100
我是内部函数inner 200
300第一个输出，函数outer()的局部变量，可见inner和a均是，函数也可作为变量
第二个输出为outer()下的a的值
第三个输出调用了inner()的print语句，执行了inner里的内容
第四个，由于执行了inner()，使用nonlocal调用了外部函数的a,并使a=a+b，结果为300
函数闭包：
闭包是函数及其相关的引用环境组合而成的实体：（即 闭包 = 函数快+引用环境）
如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包。
函数闭包需满足以下几点：
1.嵌套函数
2.内部函数引用了外部函数的变量
3.返回值是内部函数
举例说明：
以下情况称为闭包
# 闭包举例 以下情况称作闭包
def outer(n):
a = 10
def inner():
b = a + n
print('内部函数：', b)
return inner #返回的是inner的地址
r = outer(5) #r接住了inner的地址
print(r)
r() #相当于执行inner输出：
<function outer.<locals>.inner at 0x000001B475CCA4C0>
内部函数： 15装饰器：
装饰器遵循”开放-封闭“原则：对实现功能代码块封闭
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?对扩展开放
使用装饰器目的：在不改变原函数的前提下增加函数的功能，降低函数冗余性
定义：
def aaa(func):
def xxx(*args,**kwargs):
......
func()
......
return yyy
return xxx装饰：
@装饰器名 ----> 原函数 = 装饰(原函数)
def 原函数():
pass简单装饰器举例：
#定义装饰器
def decorater(func): #必须有参数
def wrapper():
# func() #调用func函数，该函数为house
print('刷漆')
print('装修房子')
print('------------------>')
return wrapper #不加括号为返回函数的地址
#使用装饰器
@decorater
def house():
print('毛坯房...')
house() #此时house地址为wrapper的地址@decorater的底层动作： 变相执行装饰器decorater(func) ? ? 把该标识下面的函数house作为decorater的参数，接收装饰器的返回值，等价于 house = decorater (house)，huose接收了wrapper的地址，house称为被装饰函数
装饰器功能：
1.引入日志
2.函数执行时间统计
3.执行函数前预备处理
4.执行函数后清理功能
5.权限校验等场景
6.缓存
原函数带参数时——装饰器：
注意：如果原函数有参数，则装饰器的内部函数也要有参数，两者参数名可不同；
? ? ? ? ? ?当原函数传入多个参数时，可在装饰器内部使用可变参数 *args 。
举例说明：?
当装饰器内部同时使用可变参数 *args和**kwargs，此时为万能装饰器，不受函数参数的限制
#带参数的装饰器
def decorater(func):
def weapper(*args,**kwargs): #此时为万能装饰器
# args 是一个元组 ('北京五环',1000)
func(*args,**kwargs) #利用了 * 拆包
print('刷漆')
print('装修房子')
return weapper
@decorater
def house(address):
print('房子的地址是：{}，是一个毛坯房......'.format(address))
@decorater
def workspace(address,area):
print('车间在{}，有{}平米'.format(address,area))
house('魏都大厦') #house就是wrapper
workspace('北京五环',1000)
输出：
房子的地址是：魏都大厦，是一个毛坯房......
刷漆
装修房子
车间在北京五环，有1000平米
刷漆
装修房子带返回值的装饰器：
该代码执行顺序为：
1.从@decorater 开始，people作为函数decorater的参数(func=people)，再返回wrapper的地址给people，使其(people和wrapper)地址空间相同。
2.执行?r = people() ，打印people的语句，再进入wrapper，使 r = 785，再依次打印并返回值 785 给全局变量 r
3.最后将 r(785)?打印
def decorater(func):
def wrapper(*args,**kwargs):
r = func(*args,**kwargs) #是people的返回值，785
print('===========================')
print('我是钢铁侠')
return r
return wrapper
@decorater
def people():
print('I am IronMan...')
return 785
r = people() #people就是wrapper，仅仅赋值也会执行people(wrapper)，执行时相当于将people()内容拼接在wrapper()内容的上面
print(r)
输出：
I am IronMan...
===========================
我是钢铁侠
785多层装饰器：
注意：多层装饰器指原函数被多个装饰器嵌套装饰，若出现该情况，则产生“就近原则”，即谁距离原函数最近则优先使用哪个装饰器。
举例说明：
# 多层装饰器
def decorater1(func):
print('第一个装饰器')
def wrapper(*args, **kwargs):
func()
print('第一个wrapper')
return wrapper
def decorater2(func):
print('第二个装饰器')
def wrapper(*args, **kwargs):
func()
print('第二个wrapper')
return wrapper
@decorater1
@decorater2
def jsy():
print('Hello World !')
jsy()
输出：
第二个装饰器
第一个装饰器
Hello World !
第二个wrapper
第一个wrapper可以看到，由于“就近原则”，先执行距离函数jsy最近的装饰器decorater2。
装饰器本身有参数时：
注意：
1.带参数的装饰器是三层的
2.最外面的函数负责接收装饰器的参数
3.里面的内容还是原装饰器的内容
4.不要忘了装饰器也要返回
举例说明：
# 装饰器带参数
def outer(a): #第一层：负责接收装饰器参数
def decorater(func): #第二层：负责接收函数
def wrapper(*args, **kwargs): #第三层：负责接收函数参数
func(*args, **kwargs)
print('今年{}岁'.format(a))
return wrapper
return decorater #注意装饰器的返回
@outer(a=10)
def house(name):
print('我的名字是{}'.format(name))
house('jsy')输出：
我的名字是jsy
今年10岁嵌套函数，闭包，装饰器之间联系：
一个嵌套函数，外层函数将内层函数返回出来，叫做闭包
一个闭包，往内层函数的参数中传入函数，形成了装饰器
第四节：
递归函数：
递归函数的本质类似于我们俗称的“套娃”，本身较少使用，一般用于文件操作，且递归次数过多会出现报错。
定义：
一个函数在内部不调用其他函数而是有限次调用本身。
1.递归必须设定终点(执行次数有限)
2.递归通常有一个入口(即传入参数)
举例（打印数字1~10）：
# 打印数字 1~10
def test(i):
if i == 10:
print('10') # 此情况递归结束. 需先考虑递归结束的情况
else:
print(i)
i += 1
test(i) # 否则的情况下，调用递归
test(1)设参数为1，是从1~10打印输出，控制打印起点；且在不满足 i = 10 的情况下，递增i并且对对函数本身进行递归。
举例（实现1~10的累加）：
# 实现1~10的累加
def test1(i):
if i == 10:
return 10
else:
return i + test1(i + 1)
r = test1(10)
print(r)举例（斐波那契数列）：
# 斐波那契数列
def fbnq(i): # i为斐波那契数列数字顺序
if i > 2:
return fbnq(i - 1) + fbnq(i - 2)
else:
return 1
r = fbnq(8)
print(r)打印出斐波那契数列的第8个数值
（21）
匿名函数：
1.用lambda 关键词能创建小型匿名函数
2.省略了用def创建函数的标准步骤，具有简洁性
使用方式：
lambda? 参数列表：(返回值)运算表达式
举例说明：
r = lambda a: a + 1 # r是匿名函数的名字
print(r)
print(r(1))输出：
<function <lambda> at 0x00000164F3DDC430>
2第一个输出匿名函数的地址空间
第二个输出匿名函数的返回值
匿名函数作函数的参数：
使用场合：当函数需要作参数时，为了简便性，可以将其定义为匿名函数。
举例说明:
#匿名函数做参数
def jsy(x,y,func): #func是一个函数参数
print(x,y)
print(func) #打印了匿名函数的地址
result = func(x,y) #执行匿名函数并将返回值赋给result
print('{}+{}={}'.format(x,y,result))
jsy(1,2,lambda x,y:x+y) #匿名函数作为jsy函数的第三个参数出现输出：
1 2
<function <lambda> at 0x000001E98906C670>
1+2=3定义匿名函数并传给func，然后在jsy()里调用匿名函数，并返回值给result
匿名函数与内置函数结合使用：
高阶函数：一个函数在另一个函数中作参数使用
一些内置函数：
max:找最大值
min:找最小值
sorted:对列表进行排序? ? ? 用法：sorted(可迭代式 , 查找的key , reverse是否倒序)
filter类:用来过滤一个列表里符合规定的所以元素，得到结果是一个迭代器(filter对象)
map类:将列表里的每一项数据都进行相同操作，得到的结果是一个迭代器(map对象)
reduce:(不是系统函数)，使用前要导入?from functools import reduce，
###? ?max函数与lambda的结合使用
sorted(iterable,?key=?None,?reverse?=?False)，第一个参数是可迭代内容，第二个参数为待比较的关键字，也可以是一个函数的返回值(所以使用匿名函数更加便捷)，第三个参数控制是否倒序输出。
#max函数与lambda的结合使用
list1 = [['tom',19],['tony',20],['lily',18],['danniel',22]]
m = max(list1,key=lambda x:x[1])
print(m)输出：
['danniel', 22]由于key值是max函数要进行比较大小的值，故使lambda函数的返回值为第二层列表里的第二个值，并将其指向了key，然后用max函数进行比较。
min,max,sorted的使用均与key有关。
###? ?map与lambda的结合使用
使用map时需注意，map(function,iterable): 第一个参数是函数，第二个参数是可迭代内容
用于遍历列表，对其中元素进行统一操作的。
举例说明：
list1 = [['tom',19],['tony',20],['lily',18],['danniel',22]]
m = map(lambda x:x[0],list1) #map(函数，可迭代式)
print(m)
print(list(m)) #将map对象强转为list输出：
<map object at 0x00000178A1284280>
['tom', 'tony', 'lily', 'danniel']第一个输出为map对象的地址空间
第二个输出为? ?将map强转为list
###? ?filter与lambda的结合使用
注意：filter的匿名函数要求返回值必须是bool类型，只有条件为真才满足过滤要求
filter第一个参数是函数，第二个参数是可迭代式；用于筛选元素
举例：
list1 = [['tom',19],['tony',20],['lily',18],['danniel',22]]
result = filter(lambda x:x[1]>20,list1) #迭代list1中的内容
print(result)
print(tuple(result))输出：
?
<filter object at 0x0000023EDD2448B0>
(['danniel', 22],)像过滤器一样，对list1进行迭代，选择出满足lambda函数里条件的，进行输出
###? ?reduce与lambda的结合使用
reduce有三个参数，第一个为函数，第二个要是序列，第三个是初始值默认为None；可用于对序列的累加，减乘除
from functools import reduce
r = reduce(lambda x,y:x+y,[1,2,3,4,5]) #列表元素累加
print(r)
要先在 functools 里导入 reduce，才能使用。
输出相当于对列表里的元素进行了累加操作。
1,2? --->3
3,3 ---->6
6,4 ----->10
10,5 ----->15 (返回最后结果)
当出现第三个参数时：
list1 = [1]
r = reduce(lambda x, y: x - y, list1, 2)
print(r) # 说明初始化值赋给了x，list1中的唯一元素给了y，使x-y=1输出：
1说明初始化值赋给了x，list1中的唯一元素给了y，使x-y=1
? ?