您好,登录后才能下订单哦!
密码登录
登录注册
点击 登录注册 即表示同意《亿速云用户服务条款》
def sum(*iterable):
print(type(iterbale)) # iterbale ==> 元组,不传入为空元组
for i in iterable:
pass
def sum1(iterable):
print(type(iterbale))
for i in iterable:
pass
sum(x for i in range(10))) # 传入生成器
sum1(range(5))) # 传入一个对象
def fn(a, b=5, *args, **kwargs):
pass
fn(5, a=2, c=3, b=4,z=5)
##位置参数和关键字参数混用,关键字参数可以乱序,多余的kwargs收集为字典
def fun(x=4, *args, y, **kwargs):
# y只能接受关键字参数,keyword-only参数
pass
def func(*args, x=0, y): # 正确,keyword-only 默认值可以在前
pass
def func1(*,m): # m 必须为关键字传参
pass
def fun(a, b):
pass
fun(**{"a":1,"b",2}) # ==> fun(a=1,b=2)
fun(*{"a":1,"b",2}.values()) # ==> fun(*(1,2))
def func():
x = 1
def fn():
x = x + 1 # 调用时将会报错,未定义本地x的值之前,使用了本地的x
def func:
global x # 声明全局作用域,必须是全局作用域,上一层使用的nonlocal
x = 1 # 在函数中可以定义全局变量,且执行后外部可用
x += 1
def func():
x = [1]
def fn():
x.append[4]
return fn
foo = func()
foo() # 每次输出将会在上一次的结果上增加一个元素;x 的操作与外部形成了闭包
2.也可以使用nonlocal实现闭包:内部变量声明使用外部定义的变量
def func():
x = 1
def fn():
nonlocal x #声明该x 是外部变量 x
x = x + 1
return fn
foo = func()
foo() # 每次调用x 结果加1,foo函数未消亡,x 将不会被清除
def func():
x = 1
def fn():
y = x + 1 # 此处使用了x 变量,但是在下一行才定义x 所以错误
x = y # 此处定义了与外部变量同名变量,在本函数内部所有范围内只能用该变量
# 如果没有第5行对x的重新定义,第4行中x将会使用外部的x变量
def fn():
global c
c = 0
def fn1():
c = 0
def fn2():
def fn3():
nonlocal c # 会使用5行的c值,与第3行的c不是同一个比变量
#若没有第5行的c定义,也无法匹配第3行的c变量。nonlocal无法匹配global变量
def fun(a, b=1, c={}, *d , m=1, **kw):
a = 1
x = 1
return x
dir(fun) # 查看该函数定义后的已经存在属性
'''
['__annotations__', '__call__', '__class__', '__closure__',
'__code__', '__defaults__', '__delattr__', '__dict__',
'__dir__', '__doc__', '__eq__', '__format__', '__ge__',
'__get__', '__getattribute__', '__globals__', '__gt__',
'__hash__', '__init__', '__init_subclass__', '__kwdefaults__',
'__le__', '__lt__', '__module__', '__name__', '__ne__',
'__new__', '__qualname__', '__reduce__', '__reduce_ex__',
'__repr__', '__setattr__', '__sizeof__', '__str__',
'__subclasshook__']
'''
# 默认值被保存到 __defaults__ 和 __kwdefaults__中,分别保存位置参数
# (使用元组)和kw-only参数(使用字典)
fun.__defaults__ # ==> ( 1, {} ) 保存了b和c的缺省值
fun.__kwdefaults__ # ==> {'m': 1} 保存了m 的默认值
def fun(x = [], b=1):
x.append(1) # 此时 x 是默认值列表中对象,直接操作默认值参数的对象
x += [1] # += 执行列表的extend,也是对x本对象的改变
b = 2 #b原本指向默认值列表中的1,现在指向新的对象2,原对象未改变
print = 1 # 定义一个变量为print,此时print指向一个int对象,
print(1) # 此时将会报错,默认先使用本文件中的print,而不是build-in中
lambda x : x + 1 # 返回值===> 对象,":"后不能出现赋值表达式
foo = lambda x : x + 1 # ===> 返回的对象使用一个变量接收,foo可调用
(lambda x : x+1)(1) # ==> 直接在创建后调用,()+ 传入参数调用
# 返回一个和str功能相同的函数对象,效果相同
sorted([1,2,3,"a"], key = str)
sorted([1,2,4,"a"], key = lambda x :str(x))
# 可以定制一些自己的比较方式,例如:
sorted([1,2,4,"a"], key = lambda x :hash(x)) # 使用元素哈希值排序
sorted([1,2,4,"a"], key = lambda x :func(x)) # func为自己定义的函数,实现自定义
d = defalutdict(lambda :0)
for k in "abc":
d[k] += 1 # 第一次将会调用lambda并返回初始值0值,完成累加
d = defalutdict(lambda :[]) # 构造列表 == list
for k in "abc":
d[k].append(1)
def fun():
x = [ ]
return lambda a : x.append(a) # 匿名函数使用外层函数x,形成闭包
def func(n):
if n == ? # 退出条件,可能不止一个
return ? # 一个确定的值,不可以再调用自身
return func( n - 1 ) # 根据实际递推公式变化
import sys
print(sys.getrecursionlimit()) # ==> 最大递归数
def func():
for i in range(3):
yield i # 执行到yield,返回一次结果,并暂停函数执行
f = func() # 调用函数将不会执行,而是返回一个生成器对象
next(f) # 使用next(),返回每次yield值
每次调用函数func 将会返回一个新的生成器,不能直接对func()进行操作,否则每次生成新的对象。
def foo():
i = 0
while True:
i += 1
res = yield i #yield 的默认返回值None,外部使用send后将返回send值
print(res)
g = foo()
g.send("abc") # 执行next(g),并将"abc"作为生成器g内部yield的返回值
使用案例:重置计数器,send任意值重置计数
def foo():
i = 0
while True:
i += 1
res = yield i # 第一次执行会返回i, 然后暂停函数的执行
if res is not None: # 当收到send值,重置计数器i
i = 0
print(res) # 下一次next,才会使用res 即"abc"
g = foo() # 生成器对象
g.send("abc")
# 每一次执行返回可迭代对象中的一个值
def foo():
yield from [1,2,3] # 接iterable
a = [8, 7,6, 47, 464, 4, 32,3,2]
def sort(nums, *, key=None, reverse=False):
res = []
for x in nums:
for i, v in enumerate(res): #第一次不会for,append第一个元素
cx = key(x) if key else x #key实现
cv = key(v) if key else v #只用于比较,插入时使用原值
cmp = cx > cv if reverse else cx < cv # reverse实现
if cmp:
res.insert(i,x) # 找到插入位置i , 插入 x
break
else:
res.append(x)
print(res)
sort(a, reverse=1, key=str)
sorted()
排序函数:返回排序好的原列表
# sorted(iterbale, *, key=None, reverse=False)
# 结合 lambda 实现特定功能
# 使用 lambda 按照其lambda返回值的数值大小依次进行排序
sorted(a, key=lambda x: abs(x-10) ) # 以x-10的绝对值大小排序
sorted(a, key=lambda x: 1) # 原来的序列
# filter(function, iterable) ==> 迭代器,惰性对象
list(filter(int, ["0", "12"])) # ==> ["12"] #int("0")后等效false
list(filter(lambda x: int(x), ["0", "12"])) # 同上功能
filter(None, [None, 0, "False", False, [],"",(), {}]) # ['False']
# map(self, /, *args, **kwargs)
# map(func, *iterables) --> map object # 返回map对象,惰性
map(str, range(5)) # [ '0, '1', '2', '3', '4']
map(lambda x: str(x), range(5)) # 同上
map(lambda x,y: (x,y), "abcde", range(10)) # 类似zip,返回组合后的元组
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。