python实战打卡---day13

1. 含单个元素的元组

   Python中有些函数的参数类型为元组，其内有1个元素，这样创建是错误的：

   c=(5)# 它实际创建⼀个整型元素5，必须要在元素后加⼀个逗号 :
   c=(5,)
   

2. 默认参数设为空

   含有默认参数的函数，如果类型为容器，且设置为空：

   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
   

3. 共享变量未绑定之坑

   有时想要多个函数共享⼀个全局变量，但却在某个函数内试图修改它为局部变量：

   i = 1
   def f():
       i+=1 #NO!
   def g():
       print(i)
   

   应该在f函数内显⽰声明 i 为global变量：

   i = 1
   def f():
       global i # YES!
       i+=1
   

4. 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)>]
   

5. 各种参数使用之坑

   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
   

6. 列表删除之坑

   删除⼀个列表中的元素，此元素可能在列表中重复多次：

   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]
   

7. 列表快速复制之坑

   在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
   '''
   [[], [], []]
   '''
   

8. 字符串驻留

   a = 'something'
   b = 'some'+'thing'
   id(a)==id(b) # True
   a = '@zglg.com'
   b = '@zglg'+'.com'
   id(a)==id(b) # False
   

   这与Cpython 编译优化相关，⾏为称为 字符串驻留 ，但驻留的字符串中只包含字母，数字或下划线。

9. 相同值的不可变对象

   d = {}
   d[1] = 'java'
   d[1.0] = 'python'
   d
   '''
   {1: 'python'}
   '''
   d[1] # 'python'
   d[1.0]# 'python'
   

   这是因为具有相同值的不可变对象在Python中始终具有 相同的哈希值 由于存在 哈希冲突 ，不同值的对象也可能具有相同的哈希值。

10. 对象销毁顺序

    # 创建一个类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⾏为却与之不同，通过打印顺序就可以看到。

11. 充分认识for

    for i in range(5):
        print(i)
        i=10
    '''
    0
    1
    2
    3
    4
    '''
    

    为什么不是执⾏⼀次就退出？

    按照for在Python中的⼯作⽅式, i = 10 并不会影响循环。range(5)⽣成的下⼀个元素就被解包，并赋值 给⽬标列表的变量 i .

12. 认识执行时机

    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)
    

13. 创建空集合错误

    这是Python的⼀个集合： {1,3,5}，它⾥⾯没有重复元素，在去重等场景有重要应⽤。下⾯这样创建 空集合是错误的：

    empty = {} #NO!
    

    cpython会解释它为字典 使⽤内置函数 set()创建空集合：

    empty=set()
    

14. 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()
    

    第六部分结束！！！！！！！