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