基础之函数

函数

含义:包裹一部分代码,实现某个功能,达成某个目的

特点:可以反复调用,提高代码的复用性,提示开发效率,便于维护管理

1.基本格式

def 函数名():
    code1
函数名()

2.函数命名

字母数字下划线,首字符不能为数字
严格区分大小写,且不能使用关键字
函数命名有意义,且不能使用中文哦

函数的参数

参数:配合函数运算的值就是参数
参数:
    形参:形式参数,在函数的定义处
    实参:实际参数,在函数的调用处
形参:
    (1)普通形参(位置),
    (2)默认形参, #参数上带有默认值,(实参给了,使用实参,实参没给,使用默认参数)
    (3)普通收集形参, #*args 专门收集那些没人要多余的普通实参,构成元组
    (4)命名关键字, #在*args号后面的或者(*args和**kwargs中间的是命名关键字形参)
    (5)关键字收集形参#**kwargs 专门收集那些 没人要的多余的关键字实参,构成一个字典
实参:
    (1)普通实参,
    (2)关键字实参 #1.关键字实参的顺序可以随意调整 2.普通实参必须写在关键字实参的前面
#原则:形参实参一一对应
#普通形参必须写在默认形参的前面
#区分关键字实参和默认形参的不同:一个在定义处,一个在调用处
#命名关键字形参调用时,必须指定参数的名字进行调用,也就是必须使用关键字实参的形式进行调用(指明道姓)

在函数定义处使用*和**
	* 代表最后打包成元组
    ** 代表最后打包成字典
在函数调用处使用*和**
	*代表最后把元组/列表这样的容器打散,解包
    **代表最后把字典这样的容器打散,解包
总结:
    当所有的形参都存在时,必须按照如下顺序进行定义;
    普通形参(位置) => 默认形参 => 普通收集形参 => 命名关键字形参 => 关键字收集形参
    def func(*args,**kwargs): 可以收集所有的实参

注意点:

字典.keys() -> 获取值
字典.values() -> 字典的值
字典.items() -> 字典的键值对
k,v = ('a':'字典')

函数返回值return

return返回值: 把函数内部的值返回到函数的外面
1.return + 6大标准数据类型 还可以接 类对象和函数,把返回值扔给函数的调用处
2.一旦执行return ,函数立刻终止
3.如果函数内部没有定义任何返回值,默认返回None

局部变量和全局变量

概念:
    局部变量: 定义在函数内部的变量
    全局变量: 定义在函数外部的变量,或者在函数内部用global关键字定义的变量
作用域:
    局部变量:仅限在函数的内部使用
    全局变量:从定义处开始,横跨整个文件
生命周期:
    程序启动时,空间开启的顺序:
        内置空间 => 全局空间 => 局部空间
        生命周期从长   ->   短
        内置变量 -> 全局变量 -> 局部变量
        #局部遍历:函数调用时,开启空间,调用结束后,立刻释放;
 global使用总结:
    使用global 关键字,在函数的内部定义一个全局变量,或者修改一个全局变量,有则改这,无则创建之

函数名的使用

函数可以像变量一样,动态创建,销毁,当作参数传递,叫做第一类对象,其他语言功能有限

1.函数名是个特殊的变量,可以当作变量赋值

2.函数名可以作为函数的参数

3.函数名可以作为函数的返回值

4.函数名可以作为容量类型数据的元素

#__dic__或者help查看文档
开头文档一般在函数的开头位置,用三引号""""""进行注释,这样用上述方法调取时,能够 检索到

嵌套函数

函数直接可以互相嵌套,外部的函数叫外函数,内部的函数叫内函数

内部的函数不可以直接被外部函数调用
调用外部函数后,内部函数不可以在函数外部调用
内部函数可以在函数内部调用
内部函数在函数内部调用时,没有先后顺序  # 没有先后顺序!!
必须先定义再调用
	#了解:在其他语言中存在预加载机制,会提前把函数加载到内存,然后再执行对应的代码,所以可以先调用,后定义python中没有

找寻变量的调用顺序LEGB原则(即就近找变量原则)

B --Builtin : python内内置模块的命名空间   内建作用域
G --Global: 函数外部所在的命名空间  全局作用域
E --Enclosing: 外部嵌套函数的作用域  嵌套作用域
L --Local: 当前函数内部的作用域 局部作用域
#结论:依据就近原则,从上到下,从里到外,依次寻找变量

用来修改局部变量nonlocal

nonlocal修改局域变量时,采用LEGB原则
	(1)用来修改当前作用域上一级的局域变量
	(2)如果上一级不存在,继续向上寻找变量
	(3)直到再也找不到报错
#补充:不通过nonlocal,也可以改变局部变量,通过列表
def outer():
    lst = [1,2,3]
    def inner():
        def smaller():
        	lst[0] = 100
    	snaller()
    inner()
outer()

闭包函数

概念:
	互相嵌套的两个函数
		(1)內函数使用了外函数的一个局部变量
		(2)外函数把內函数返回出来的过程叫闭包

了解:获取闭包函数使用的变量 __closure__,cell_contents

特点:
	在闭包的情况下,內函数使用了外函数的局部变量,该变量与內函数发生绑定,延长该变量的生命周期,该局部变量的周期一致持续到该脚本执行结束

意义:
	闭包可以优先使用外函数中的变量,并对闭包中的值起到了封装保护的作用,外部无法访问

匿名函数

用一句话表达只有返回值的函数,可以使用lambda 表达式
语法:
	lambda 参数: 返回值
特点:
	简洁,高效

(1)无参的lambda表达式

def func():
	return 123

(2)有参的lambda表达式

(3)带有判断的lambda表达式

补充:
三元运算符:
真值if 表达式 else 假值
	当条件满足时,返回真值,否则,返回假值

locals 和 globals用法

locals返回当前作用域所有变量

dic = locals()
当前作用域在全局空间,获取的是打印之前的所有的全局变量
当前作用域在局部空间,获取的是调用之前所有的局部空间

globals返回全局作用域的所有变量

dic = globals()
当前作用域在全局空间,获取的是打印之前的所有的全局变量
当前作用域在局部空间,获取的是调用之前所有的全局空间

利用globals创建全局变量

globals返回的是系统的一个全局变量的字典
在系统的这个全局变量的字典中,添加键值对,就等于创建全局变量

迭代器

能被next()函数调用并不断返回下一个值的对象称为迭代器(Iterator 迭代器是对象)
概念:
	迭代器指的迭代取值的工具,迭代是一个重复的过程,每次重复都是基于上次的结果而继续的,单纯的重复不是迭代
特征:
	并不依赖索引,而通过next指针(内存地址寻址)迭代所有数据,一次只取一个值,
	而不是一股脑的把所有数据放进内存,大大节省空间

#补充:dir()查看当前数据的内部成员

迭代器与可迭代性数据直接的关系

for循环底层依靠的就是迭代器,迭代器依靠next()方法,指针地址寻址的方式,找个一个个数据,遍历出来;
如果是可迭代对象,不一定时迭代器
如果是迭代器,一定是可迭代对象
可迭代对象 --> 到 --> 迭代器 
	从不能直接获取数据,到可以直接获取数据的过程,(通过next指针,地址寻址的方法找数据)

Iterator 迭代器类型 Iterable可迭代性对象

创建一个迭代器

it = iter(setvar) #方法1
it = setver.__iter__() #方法2

通过迭代器遍历数据的方式

for #全部迭代
for + next #可控制迭代的次数
next
list

高阶函数

能够把函数当成参数传递的就是高阶函数

map

map(func,Iterable)
功能:处理数据
	把Iterable中的数据一个个拿出来,扔到func函数中做处理,把处理的结果用迭代器获取出来;
参数:
	(1)func自定义函数/内置函数
	(2)Iterable 可迭代性数据(容器类型数据,range对象,迭代器)
返回值:
	迭代器
只有在调用迭代器的时候,才会真正的执行map函数

补充:
	反转字典for k,v in dec.items():

reduce

reduce(func,Iterable)
功能:计算数据
    一次性先从Iterable 拿出两个数据,扔到func当中计算,然后把计算的结果作为参数个Iterable的下一个数据再扔到func当中再计算
参数:
    func:自定义函数
    Iterable : 可迭代性数据(容器类型数据,range对象,迭代器)
返回值:
    最后计算的值

from functools import reduce

filter

filter(func,Iterable)
功能:过滤数据
    在自定义的函数中
    	如果返回True,代表当前数据保留
        如果返回False,代表当前数据舍弃
参数:
    func : 自定义函数
    Iterable : 可迭代性数据(容器类型数据,range对象,迭代器)
返回值:
    迭代器

sorted

sorted(Iterable,reverse=False,key=函数)
功能:排序数据
参数:
    Iterable : 可迭代性数据(容器类型数据,range对象,迭代器)
    reverse : reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
    key : 指定排序的规则
返回值:
    排序后的结果永远为列表#(想要得到排序好的列表，又想保留原列表)

sorted 和 sort 功能一致
区别:
	sorted : (1)可以排序所有的容器类型数据
			(2)排序完之后,返回一个新的列表
	sort : (1)只能排序列表
		   (2)直接对原列表做排序,没有返回值None

推导式

概念:
	用一行循环判断,来表达一系列数据的方式叫做推导式
    循环后面只能写单项分支,不能为双项多项巢状分支,复杂的结构不能实现
语法:
    val for val in Iterable
推导式基本写法
	[val for val in Iterable] 列表推导式
	[val for val in Iterable] 集合推导式
	[val for a,b in Iterable] 字典推导式
特点:
    追求简洁,高效
带有判断条件的推导式
带有循环嵌套的推导式

字典推导式

enumerate

enumerate(iterable,[start=0])
功能:
	枚举 : 将索引号和iterable中的值,一个一个拿出来配对组成元组,通过迭代器返回
参数:
	iterable :可迭代性数据(容器类型数据,range对象,迭代器)
	start : 可以选择开始的索引号(默认从0开始索引)
返回值:
	迭代器

zip

zip(iterable,... ...)
功能:
	将多个iterable中的值,一个个拿出来配对组成元组,通过迭代器返回
	iterable :可迭代性数据(容器类型数据,range对象,迭代器)
返回值:
	迭代器
注意点:
	具有相同索引的元素配对成元组,否则多余的舍弃
    
dic = dict(zip(kst_key,lst_values)) #zip 配和dict强转 ==> 字典

生成器

(1)生成器表达式

生成器的本质是迭代器,允许自定义逻辑的迭代器
迭代器和生成器区别:
    迭代器本身是系统内置的,重写不了,而生成器是用户自定义,可以重写迭代逻辑
生成器可以用两种方式创建:
    (1)生成器表达式 (里面是推导式,外面用圆括号)
    (2)生成器函数 (用def定义,里面含有yield)
只有在调用生成器时,生成器表达式中的代码才会执行

form collections import Iterable Iterator
gen = (i for i in range(5))
print(gen,type(gen))

(2)生成器函数

yield类似于 return
共同点在于:执行这句话都会把值返回出去
不同点在于:yield每次返回时,会记住上次离开的位置,下次再调用生成器,会从上次执行的位置往下走,而return直接终止函数,每次重头调用

自定义生成器函数
def mygen():
	print("one")
    yield 111
	print("two")
    yield 222
初始化生成器对象
gen = mygen()
#切记,在迭代器生成器的环节中,一般处理的都是大数据,不要试图获取生成器中所有数据,可能造成死循环的效果

(3)next和send的区别

next 只能取值
send 不但能取值,还能发送值
send 注意点:
	第一个send不能给 yield传值,默认只能写None
	最后一个yield 接受不到send的发送值
#默认有几个yield返回几个数据

递归函数

自己调用自己的函数
递 : 去
归 : 回
一去一回是递归

基本写法
def digui(n):
	print(n,"1====>")
    if n > 1:
        digui(n-1)
    print(n,"<2=======>")
digui(5)
栈帧空间:每次函数调用时,系统都会默认开辟一个执行函数的空间

递归的注意点

(1)递归函数就是不停的开辟空间和释放空间的过程,每调用一层函数都会单独开辟一个空间,调用结束后,自动释放空间,节省内存
(2)递归触发的过程有两个方法
	一.当最后一层栈帧空间执行完毕时,回到上一层调用空间,把没执行完的代码走完
    二.当遇到return,终止当前空间的函数,回到上一层空间的调用处;
(3)递归函数不能无休止的调用下去,会导致内存溢出,蓝屏死机,必须给一个跳出的条件
(4)栈帧空间的每一层数据都是彼此隔离,不产生影响

默认递归的上限不超过1000层空间

def func():
    func()
func()