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 服务
  • pip install pyftpdlib
  • python -m pyftpdlib -p 21
  • ftp://localhost:21

内存管理

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)。