列表碾平
需求: 将[[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
- Python2:
- 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)。
