python拾遗

列表碾平

需求: 将[[1,2],[3,4]]转换为[1,2,3,4],具体实现有以下几种方法:

   test_list = [[1,2],[3,4]]
   1. from itertools import chain
   list(chain.from_iterable(test_list))
   
   2. from itertools import chain
   list(chain(*test_list))
   
   3. sum(test_list, [])
   
   4. [x for y in test_list for x in y]
   
   5. 递归
   func = lambda x: [y for t in x for y in func(t)] if type(x) is list else [x]
   func(test_list)

PS: 项目中,难免会有类似的需求,对于结构嵌套一致的情况,上述的 1,2,3,4 方法都 可以很好的解决(不建议用 for 循环嵌套的方式,那是最 low 的方法,没有之一);对于结构 嵌套不一致的情况,第 5 种方法就派上了用场,其采用了递归的思想,堪称万能的方法,屡 试不爽。项目中,大家可以根据实际应用场景来挑选最适合自己的方法。

三目操作符

代码参考:

print(1 == 1 and 2 or 3)  # 2
print(1 == 2 and 2 or 3)  # 3
print(2 if 1 == 1 else 3)  # 2
print(2 if 1 == 2 else 3)  # 3

PS:习惯于 if else 的同学偶尔用下 and or 是不是会给人耳目一新的感觉。

and or 分开来用

1 and 2 and 3 返回3
1 and 2 and '' 返回''
'' and 2 and 0 返回''

PS:如果都为真则返回最后一个值,如果其中某些值为假,则返回第一个为假的值

1 or '' or 0 返回1
'' or 0 or [] 返回[]

PS:如果都为假返回最后一个值,如果其中某些值为真,则返回第一个为真的值

使用场景:在项目中我们经常会有这样的需求,在将一个字典更新之后还想要返回更新后的 字典,这是我们就可以这样写:dic = dic1.update(dic2) or dic1

列表推导式

需求:将列表中每个元素加1

[x+1 for x in range(1,4)]

PS: 列表推导式底层是用 C 实现的,其执行速度要比 for 循环快好多

vars()用法

def func(a, b, c):
    print(vars())

func(1, 2, 3)  # {"a":1,"b":2,"c":3}

PS:vars()的值为字典,其键值对来源于当前作用域的所有变量。

使用场景:在调用他人接口或方法时,需要将传入的参数打印以记录日志,此刻vars()便派上用场了。

偏函数之 partial

import functools

def add(a, b):
    return a + b
print(add(4, 2))  # 6

plus3 = functools.partial(add, 3)
print(plus3(1))  # 4

使用场景: 当我们需要同时去调用一个函数,并且发现大部分参数一致的时候,便可以采取上述方法,一来代码简洁,二来可读性高。

Python 搭建简易服务

  • Python 搭建简易邮件服务器
    • python -m smtpd -n -c DebuggingServer localhost:1025
  • Python 搭建简易 web 服务器
    • Python2: python -m SimpleHTTPServer port
    • Python3: python -m http.server port
  • Python 搭建简易 ftp 服务

内存管理

Python 的内存管理主要分为引用计数和垃圾回收机制两大部分,且看下面代码:

内存分配

a = 1
b = 1
a is b  # True

a = 10000
b = 10000
a is b  # False

在 Python 中,整数和短小的字符,解释器都会缓存这些对象,以便重复使用。
当我们创建多个等于 1 的引用时,实际上是让这些引用指向了同一个对象。

引用计数

在 Python 中,所谓引用计数(reference count)是指所有指向该对象的引用的总数;

我们可以使用 sys 包中的 getrefcount(),来查看某个对象的引用计数。需要注意的是,当使用该函数查看某个对象的引用计数时,实际上是临时创建了该对象的一个新的引用,所有使用 getrefcount()所得到的结果,会比期望的值多 1。

from sys import getrefcount
aa = 'test refcount' 
print(getrefcount(a))
bb = aa 
print(getrefcount(a))

引用减少

引用减少大致分为两类:

  • 指向该对象的引用指向了其他对象

    from sys import getrefcount
    
    aa = 'test refcount'
    bb=aa
    print(getrefcount(aa))  # 3
    bb=1
    print(getrefcount(aa))  # 2
    
  • 使用del关键字显示的删除某个引用

    from sys import getrefcount
    aa = 'test refcount'
    bb=aa
    print(getrefcount(aa))  # 3
    del bb
    print(getrefcount(aa))  # 2
    
    

垃圾回收

不断的创建对象,如果不及时销毁的话,那 Python 的体积会越来越大,再大的内存也会有耗完的时候;不用像 C 语言那样,需要手动的去管理内存、Python 已经帮我们做好了(Python 的垃圾回收机制),你只需要去关心你的业务逻辑即可,其他的都交给 Python 来处理。

从原理上讲,当 Python 中某个对象的引用计数降为 0 时,该对象就应该被回收。但是频繁的启动垃圾回收机制毕竟是个很耗时的问题;因此 Python 只有在特定条件下(当 Python 中被分配对象和取消分配对象的次数之间的差值达到某个阈值时),Python会自动启动垃圾回收机制。

我们可以通过 gc 模块的 get_threshold()方法,查看该阈值:

import gc
print(gc.get_threshold())

该方法会返回(700, 10, 10),后面的俩 10 是与分代回收相关的,稍后讲解。700 便是垃圾回收机制启动的阈值。可以通过 gc 模块中的 set_threshold()方法重新设定该值。
当然了,我们也可以手动启动垃圾回收机制,使用 gc.collect()即可。

分代回收

Python 同时采用了分代回收的机制,设想一下:存活越久的对象、越不可能是垃圾对象。程序在运行时,往往会产生大量的临时对象,程序结束之后,这些临时对象的生命周期也就随之告一段落。但有一些对象会被长期占用,垃圾回收机制在启动的时候会减少扫􏰀到他们的频率。

Python 将所有对象分为 0,1,2 三代。所有新创建的对象都是 0 代,当垃圾回收机制在启动多次 0 代机制并扫􏰀到他们的时候,这些对象如果依然存活在内存的话,他们就会被归入下一代对象,以此类推。

刚才上面所􏰁到的(700, 10, 10),700为垃圾回收启动的阈值(即对象的分配次数和释放次数的差值),后面的俩 10 所代表的意思是:每 10 次 0代垃圾回收,会配合 1 次 1 代的垃圾回收;而每 10 次 1 代的垃圾回收会配合 1 次的2 代垃圾回收。

当然我们同样可以使用 set_threshold()来调整此策略的比例,比如对 1 代对象进行更频繁的扫描。

import gc
gc.set_threshold(700, 5, 10)

gc.get_count()会返回当前垃圾回收状态:

  • 当计数器从(699,0,0)增加到(700,0,0),gc模块就会执行gc.collect(0),即检查0代对象的垃圾,并重置计数器为(0,1,0)
  • 当计数器从(699,9,0)增加到(700,9,0),gc模块就会执行gc.collect(1),即检查0,1代对象的垃圾,并重置计数器为(0,0,1)
  • 当计数器从(699,9,9)增加到(700,9,9),gc模块就会执行gc.collect(2),即检查0,1,2代对象的垃圾,并重置计数器为(0,0,0)。

推荐阅读更多精彩内容