Python之函数

1. 函数参数

（1）形参：函数定义时的参数

（2）实参：函数调用时的参数

（3）收集参数：

　　　　普通收集参数：*args，收集多余的普通参数，组成一个元组

　　　　关键字收集参数：**kw，收集多余的关键字参数，组成一个字典

（4）命名关键字参数：函数定义时放在 * 号后面，调用时必须指定关键字实参；（*，abc）abc是命名关键字参数

（5）* 和 ** ：打包和解包

　　函数定义处：打包（收集参数，放到元组或字典中）

　　函数调用处：解包（把容器类型里的数据，一个个拿出来传递给函数的形参）

（6）形参声明的顺序：

　　普通参数 > 默认参数 > 收集参数 > 命名关键字参数 > 关键字收集参数

（7）对于任何函数，都可以使用 def func(*args,**kw)来获取所有的参数

 

2. 内置函数

abs：绝对值

round：四舍五入

sum：求和

max：求最大值

min：求最小值

pow：n次方

range：产生指定范围的可迭代对象

 

bin：将十进制转成二进制

oct：将十进制转成八进制

hex：将十进制转成十六进制

 

chr：将二进制字节流转成字符串

ord：将字符串转成二进制字节流

 

eval：将字符串当做Python代码执行

exec：将字符串当做Python代码执行

 

repr：不转义字符输出字符串

input：接收输入的字符串

hash：生成哈希值

 

3. 全局变量和局部变量

　　全局变量：函数外部的变量，作用范围：整个文件

　　局部变量：函数内部的变量，作用范围：仅函数内部

　　内置函数：内建命名空间

关键字：

　　globals（）：返回字典，存放全局作用域所有内容

　　locals（）：返回字典，存放当前作用域的所有内容

　　global：关键字：声明或修改全局变量

　　nonlocal：关键字：修改局部变量（当前函数上一层的局部变量）

4. LEGB原则（就近原则）

变量的调用顺序采用LEGB原则

B -- Builtin（Python）；Python内置模块的命名空间

G -- Global（module）；函数外部所在的命名空间

E -- Enclosing function locals；外部嵌套函数的作用域

L -- Local（function）；当前函数内的作用域

依据就近原则，从上往下，从里到外依次寻找

5. 闭包

# 获取闭包函数使用的变量 __closure__，cell_contents

（1）定义：内函数使用外函数的局部变量，并且外函数把内函数返回出来的方法叫闭包；返回的内函数叫闭包函数。

（2）特点：内函数使用了外函数的局部变量，外函数的局部变量与内函数发生绑定，延长该变量的生命周期

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

 

6. lambda表达式

　　定义：用一句话表达只有返回值的函数。

　　语法：

　　　　lambda 参数 ：返回值

# （1）没有参数的 lambda 表达式
def func():
    return "abc"
func = lambda : "abc"
res = func()
print(res)

# （2）有参数的 lambda 表达式
def func(num):
    return num ** 2
func = lambda num : num ** 2
res = func(3)
print(res)

"""
三目运算符：
    真区间值  if  条件表达式  else  假区间值
"""

# （3）带有判断条件的 lambda 表达式
def func(n):
    if n % 2 == 0:
        return "偶数"
    else:
        return "奇数"
func = lambda n : "偶数" if n % 2 == 0 else "奇数"
res = func(3)
print(res)

 

7. 迭代器

定义：能被 next 方法调用，并且不断获取下一个值的对象，叫迭代器（对象）

特征：迭代器会生成惰性序列，通过计算把值依次返回，边循环边计算而不是一次性返回所有值

优点：一次取一个值，节省空间

总结：

　　（1）惰性序列，节省内存空间

　　（2）遍历获取数据使用 next，方向不可逆

　　（3）迭代器可以遍历无限大的数据

可迭代对象：如果该对象成员中有 __iter__ 方法，就是可迭代对象。（dir 查看内部成员）

定义一个迭代器

（1）iter(可迭代对象)（推荐使用）

（2）可迭代对象.__iter__()

# 定义一个迭代器
setvar = {"a","b","c","d"}
it = iter(setvar)

判断一个迭代器

# 判断一个迭代器 1
lst = dir(it)
res = "__iter__" in lst and "__next__" in lst
print(res)

# 判断一个迭代器 2      （迭代器类型  可迭代对象类型）
from collections import Iterator,Iterable
res = isinstance(it,Iterator)
print(res)

调用迭代器

# 调用迭代器
# （1）next 方法
res = next(it)
res = next(it)
res = next(it)
res = next(it)
print(res)

# （2）重置迭代器
it = iter(setvar)

获取迭代器数据

# #### 获取迭代器中的数据
# （1）next
res = next(it)
print(res)

# （2）for 循环
for i in it:
    print(i)

# （3）for + next
for i in range(2):
    res = next(it)
    print(res)

8. 高阶函数

map

map(func,Iterable)

功能：

　　把 Iterable 可迭代对象中的值，逐个拿出来放到 func函数中进行处理，把处理的结果放到迭代器中返回出来

　　Iterable：可迭代对象（容器类型）

返回值：

　　迭代器

# ### map函数
lst = ["1,"2","3","4"]
lst_new = []
for i in lst:
    lst_new.append( int(i) )
# map 改写
it = map(int,lst)
lst_new = list(it)

 

reduce

reduce(func,Iterable)

功能：

　　从Iterable 中一次性拿出2个数据，放到 func函数中进行计算，然后计算的结果和 Iterable 中的第三个数据再放到 func函数中，依次类推直到返回最终的结果。

返回值：

　　最后计算的结果

# ### reduce 函数
lst = [1,2,3,4] # --> 1234
# （1）
strvar = ""
for i in lst:
    strvar += str(i)
intvar = int(strvar)
print(intvar)
# （2）reduce
from functools import reduce
def func(x,y):
    return x * 10 + y
intvar = reduce(func,lst)
print(intvar)

 

sorted

sorted(Iterable,key=函数,reverse=False)

功能：排序

参数：

　　Iterable： 可迭代对象（容器类型数据、range对象、迭代器）

　　key：函数（自定义函数、或内置函数）

　　reverse = False 从小到大排序，reverse = True 从大到小排序

返回值：

　　排序后的结果（列表）

# ### sorted 函数
# （1）
tup = (1,3,2,11,-1,0)
lst = sorted(tup)
print(lst)

# （2）
tup = (1,3,2,55,11,24)
def func(n):
    return n % 10
lst = sorted(tup,key=func)
print(lst)

总结：

　　sort　　只能针对列表进行排序，直接修改原有列表

　　sorted　容器类型数据都可以排序，产生一个新的数据，数据类型是列表

 

filter

filter(func,Iterable)

功能：

　　过滤

　　在自定义函数中，如果返回True，则保留该数据；如果返回False，则舍弃该数据。

返回值：

　　迭代器

# ### filter 函数
# （1）普通方法
lst = [1,2,3,4,5,6,7,8]
lst_new = []
for i in lst:
    if i % 2 == 0:
        lst_new.append(i)
print(lst_new)

# （2）filter
def func(n):
    if n % 2 == 0:
        return True
    else:
        return False
it = filter(func,lst)
lst_new = list(it)
print(lst_new)

# （3）匿名函数
it = filter(lambda n : True if n % 2 == 0 else False,lst)
lst_new = list(it)
print(lst_new)

9. 推导式

 通过一行循环判断，遍历出一系列数据的方式是推导式

　　列表推导式：[ var for var in Iterable ]

　　集合推导式：{ var for var in Iterable }

　　字典推导式：{ a:b for a,b in Iterable }

列表推导式

# （1）单循环推导式
lst = []
for i in range(1,11):
    lst.append(i)
print(lst)
# 改写成推导式
lst = [ i for i in range(1,11) ]
print(lst)

# （2）带有单项分支判断条件的单循环推导式
lst = []
for i in range(1,11):
    if i % 2 == 0:
        lst.append(i)
print(lst)
# 改写成推导式
lst = [ i for i in range(1,11) if i % 2 == 0 ]
print(lst)

# （3）多循环推导式
lst1 = [1,3,5,7,9]
lst2 = [2,4,6,8,10]
lst_new = []
for i in lst1:
    for j in lst2:
        lst_new.append( i + j )
print(lst_new)
# 改写成推导式
lst_new = [ i + j for i in lst1 for j in lst2 ]
print(lst_new)

# （4）带有判断条件的多循环推导式
lst1 = [1,3,5,7,9]
lst2 = [2,4,6,8,10]
lst_new = []
for i in lst1:
    for j in lst2:
        if lst1.index(i) == lst2.index(j):
            lst_new.append(i + j)
print(lst_new)
# 改写成推导式
lst_new = [ i + j for i in lst1 for j in lst2 if lst1.index(i) == lst2.index(j) ]
print(lst_new)

 字典推导式

（1）enumerate(Iterable,[start=0])

功能：枚举，将索引号和Iterable的值，一个个拿出来组成元组放到迭代器中。

参数：

　　Iterable：可迭代对象

　　start：开始的索引号（默认从 0 开始）

返回值：迭代器

listvar = ["a","b","c","d","e","f"]
dic = dict(enumerate(listvar))
print(dic)

# 字典推导式
dic = { b:a for a,b in enumerate(listvar) }
print(dic)

（2）zip(Iterable1 , Iterable2 , Iterable3 ... )

功能：将多个 Iterable 中的值，按照顺序一个个拿出来组成元组放到迭代器中，多出来的元素自动舍弃掉。

返回值：迭代器

lst1 = [1,2,3,4]
lst2 = ["a","b","c"]
lst3 = ["@","#","$","%"]
tup = tuple(zip(lst1,lst2,lst3))
print(tup)

# 字典推导式
dic = dict({ b:a for a,b in zip(lst1,lst2) })
print(dic)

# 
dic1 = {"a":1,"b":2,"c":3}
dic2 = {1:100,2:200,3:300}
dic = dict( { a:b for a,b in zip(dic1.keys(),dic2.values()) } )
print(dic)

 

10. 生成器

生成器：使用了 yield 的函数被称为生成器。

生成器是一个返回迭代器的函数，只能用于迭代操作，或生成器就是一个迭代器。

调用一个生成器函数，返回一个迭代器对象。

# 生成器
def fib(n):
    a,b,count = 0,1,0
    while count <= n:
        yield a
        a , b = b , a + b
        count += 1
f = fib(10) # 返回一个迭代器
lst = list(f)
print(lst)

#
try:
    f = fib(10)
    while True:
        print(next(f))
except:
    pass