-
含单个元素的元组
Python中有些函数的参数类型为元组,其内有1个元素,这样创建是错误的:
c=(5)# 它实际创建⼀个整型元素5,必须要在元素后加⼀个逗号 : c=(5,)
-
默认参数设为空
含有默认参数的函数,如果类型为容器,且设置为空:
def f(a,b=[]): # NO! print(b) return b ret = f(1) ret.append(1) ret.append(2) # 当再调⽤f(1)时,预计打印为 [] f(1) # 但是却为 [1,2] ''' [] [1, 2] [1, 2] '''
这是可变类型的默认参数之坑,请务必设置此类默认参数为None:
def f(a,b=None): # YES! pass
-
共享变量未绑定之坑
有时想要多个函数共享⼀个全局变量,但却在某个函数内试图修改它为局部变量:
i = 1 def f(): i+=1 #NO! def g(): print(i)
应该在f函数内显⽰声明 i 为global变量:
i = 1 def f(): global i # YES! i+=1
-
lambda自由参数之坑
排序和分组的key函数常使⽤lambda,表达更加简洁,但是有个坑新⼿容易掉进去:
a = [lambda x: x+i for i in range(3)] # NO! for f in a: print(f(1)) ''' 3 3 3 '''
预期输出是1,2,3,但是实际却输出: 3,3,3. 定义lambda使⽤的 i 被称为⾃由参数,它只在调⽤lambda函数时,值才被真正 确定下来,这就犹如下⾯打印出2,你肯定确信⽆疑吧。
a = 0 a = 1 a = 2 def f(a): print(a)
正确做法是转化 ⾃由参数 为lambda函数的 默认参数 :
a = [lambda x,i=i: x+i for i in range(3)] # YES! a
[<function __main__.<listcomp>.<lambda>(x, i=0)>, <function __main__.<listcomp>.<lambda>(x, i=1)>, <function __main__.<listcomp>.<lambda>(x, i=2)>]
-
各种参数使用之坑
Python强⼤多变,原因之⼀在于函数参数类型的多样化。⽅便的同时,也为使⽤者带来更多的约束规 则。如果不了解这些规则,调⽤函数时,可能会出现如下⼀些语法异常:
(1) SyntaxError: positional argument follows keyword argument
(2) TypeError: f() missing 1 required keyword-only argument: ‘b’
(3) SyntaxError: keyword argument repeated
(4) TypeError: f() missing 1 required positional argument: ‘b’
(5) TypeError: f() got an unexpected keyword argument ‘a’
(6) TypeError: f() takes 0 positional arguments but 1 was given
总结主要的参数使⽤规则
位置参数
位置参数 的定义: 函数调⽤ 时根据函数定义的参数位(形参)置来传递参数,是最常见的参数类型。
def f(a): return a f(1) # 位置参数 1
位置参数不能缺少
def f(a,b): pass f(1) # TypeError: f() missing 1 required positional argument: 'b'
规则1:位置参数必须⼀⼀对应,缺⼀不可
关键字参数
在函数调⽤时,通过‘键–值’⽅式为函数形参传值,不⽤按照位置为函数形参传值。
def f(a): print(f'a:{a}')
这么调⽤, a 就是关键字参数:
f(a=1) # a:1
但是下⾯调⽤就不OK:
f(a=1,20.) # SyntaxError: positional argument follows keyword argument
规则2:关键字参数必须在位置参数右边
下⾯调⽤也不OK:
f(1,width=20.,width=30.) #SyntaxError: keyword argument repeated
规则3:对同⼀个形参不能重复传值
默认参数
在定义函数时,可以为形参提供默认值。对于有默认值的形参,调⽤函数时如果为该参数传值,则使⽤
传⼊的值,否则使⽤默认值。如下 b 是默认参数:
def f(a,b=1): print(f'a:{a}, b:{b}')
规则4:⽆论是函数的定义还是调⽤,默认参数的定义应该在位置形参右⾯
只在定义时赋值⼀次;默认参数通常应该定义成不可变类型
可变位置参数
如下定义的参数a为可变位置参数:
def f(*a): print(a)
调用方法:
f(1) #打印结果为元组: (1,) f(1,2,3) #打印结果:(1, 2, 3)
但是,不能这么调⽤:
f(a=1) # TypeError: f() got an unexpected keyword argument 'a'
可变关键字参数
如下 a 是可变关键字参数:
def f(**a): print(a) # 调用方法 f(a=1) #打印结果为字典:{'a': 1} f(a=1,b=2,width=3) #打印结果:{'a': 1, 'b': 2, 'width': 3} # 但是,不能这么调⽤: f(1) # TypeError: f() takes 0 positional arguments but 1 was given
-
列表删除之坑
删除⼀个列表中的元素,此元素可能在列表中重复多次:
def del_item(lst,e): return [lst.remove(i) for i in e if i==e] # NO!
考虑删除这个序列[1,3,3,3,5]中的元素3,结果发现只删除其中两个:
del_item([1,3,3,3,5],3) # 结果:[1,3,5]
正确做法:
def del_item(lst,e): d = dict(zip(range(len(lst)),lst)) # YES! 构造字典 return [v for k,v in d.items() if v!=e]
-
列表快速复制之坑
在python中 * 与列表操作,实现快速元素复制:
a = [1,3,5] * 3 # [1,3,5,1,3,5,1,3,5] a[0] = 10 # [10, 2, 3, 1, 2, 3, 1, 2, 3]
如果列表元素为列表或字典等复合类型:
a = [[1,3,5],[2,4]] * 3 # [[1, 3, 5], [2, 4], [1, 3, 5], [2, 4], [1, 3, 5], [2,4]] a[0][0] = 10 # [[10, 3, 5], [2, 4], [10, 3, 5], [2, 4], [10, 3, 5], [2, 4]] a ''' [[10, 3, 5], [2, 4], [10, 3, 5], [2, 4], [10, 3, 5], [2, 4]] '''
结果可能出乎你的意料,其他 a[1[0]等也被修改为10
这是因为*复制的复合对象都是浅引⽤,也就是说id(a[0])与id(a[2])门牌号是相等的。如果想要实现深复 制效果,这么做:
a = [[] for _ in range(3)] a ''' [[], [], []] '''
-
字符串驻留
a = 'something' b = 'some'+'thing' id(a)==id(b) # True a = '@zglg.com' b = '@zglg'+'.com' id(a)==id(b) # False
这与Cpython 编译优化相关,⾏为称为 字符串驻留 ,但驻留的字符串中只包含字母,数字或下划线。
-
相同值的不可变对象
d = {} d[1] = 'java' d[1.0] = 'python' d ''' {1: 'python'} ''' d[1] # 'python' d[1.0]# 'python'
这是因为具有相同值的不可变对象在Python中始终具有 相同的哈希值 由于存在 哈希冲突 ,不同值的对象也可能具有相同的哈希值。
-
对象销毁顺序
# 创建一个类SE class SE(object): def __init__(self): print('init') def __del__(self): print('del')
创建两个SE实例,使⽤ is判断:
SE() is SE() ''' init init del del False '''
创建两个SE实例,使⽤ id判断:
id(SE())==id(SE()) ''' init del init del True '''
调⽤ id函数, Python 创建⼀个 SE 类的实例,并使⽤ id函数获得内存地址后,销毁内存丢弃这个对象。
当连续两次进⾏此操作, Python会将相同的内存地址分配给第⼆个对象,所以两个对象的id值是相同的.
但是is⾏为却与之不同,通过打印顺序就可以看到。
-
充分认识for
for i in range(5): print(i) i=10 ''' 0 1 2 3 4 '''
为什么不是执⾏⼀次就退出?
按照for在Python中的⼯作⽅式, i = 10 并不会影响循环。range(5)⽣成的下⼀个元素就被解包,并赋值 给⽬标列表的变量 i .
-
认识执行时机
array = [1, 3, 5] g = (x for x in array if array.count(x) > 0)
g 为⽣成器,list(g)后返回 [1,3,5],因为每个元素肯定⾄少都出现⼀次。所以这个结果这不⾜为奇。 但是,请看下例:
array = [1, 3, 5] g = (x for x in array if array.count(x) > 0) array = [5, 7, 9]
请问,list(g)等于多少?这不是和上⾯那个例⼦结果⼀样吗,结果也是 [1,3,5],但是:
list(g) # [5]
这有些不可思议~~ 原因在于: ⽣成器表达式中, in ⼦句在声明时执⾏, ⽽条件⼦句则是在运⾏时执⾏。 所以代码:
array = [1, 3, 5] g = (x for x in array if array.count(x) > 0) array = [5, 7, 9]
等价于:
g = (x for x in [1,3,5] if [5,7,9].count(x) > 0)
-
创建空集合错误
这是Python的⼀个集合: {1,3,5},它⾥⾯没有重复元素,在去重等场景有重要应⽤。下⾯这样创建 空集合是错误的:
empty = {} #NO!
cpython会解释它为字典 使⽤内置函数 set()创建空集合:
empty=set()
-
pyecharts传⼊Numpy数据绘图失败
echarts使⽤⼴泛,echarts+python结合后的包:pyecharts,同样可很好⽤,但是传⼊Numpy的数 据,像下⾯这样绘图会失败:
from pyecharts.charts import Bar import pyecharts.options as opts import numpy as np c = ( Bar() .add_xaxis([1, 2, 3, 4, 5]) # 传⼊Numpy数据绘图失败! .add_yaxis("商家A", np.array([0.1, 0.2, 0.3, 0.4, 0.5])) ) c.render()
由此可见pyecharts对Numpy数据绘图不⽀持,传⼊原⽣Python的list:
from pyecharts.charts import Bar import pyecharts.options as opts import numpy as np c = ( Bar() .add_xaxis([1, 2, 3, 4, 5]) # 传⼊Python原⽣list .add_yaxis("商家A", np.array([0.1, 0.2, 0.3, 0.4, 0.5]).tolist()) ) c.render()
第六部分结束!!!!!!!
python实战打卡---day13
最新推荐文章于 2024-08-26 10:08:59 发布