登陆

极彩在线-Python 从业十年是种什么体会?老程序员的一篇万字经历共享

admin 2019-12-04 293人围观 ,发现0个评论

花下猫语:我“接触” Python 已有十年了,当初我们要做一个网站,有个学弟只花两天,就用 Django 开发好了后台。那是我第一次感受到了 Python 的强大魅力。不过,我正式学习和使用它,才仅有两年时间……

标题中说的“从业十年”,并不是指我,而是下面文章的作者。像他拥有这么长的 Python 经验的程序员并不多见,写成文章分享出来的就更少见了。所以这篇文章还挺有价值的,内容很丰富,特分享给大家,建议收藏。


作者:laisky(基于 CC BY 4.0 授权许可)

原题:Python之路(内容略有调整)

来源:https://laisky.com/p/python-road

一、概述

本文起源于我在 Twitter 上发布的关于 Python 经历的一系列话题。

出于某些原因,想记录一下我过去数年使用 Python 的经验和一些感悟。 毕竟算是一门把我带入互联网行业的语言,而我近期已经几乎不再写 Py 代码, 做一个记录,也许会对他人起到些微的帮助,也算是纪念与感恩了。

二、摘录

推文地址:https://twitter.com/ppcelery/status/1159620182089728000


最早接触 py 是 2010 年左右,那之前主要是使用 c、fortran 和 matlab 做数值运算。当时在做一些文件文本处理时觉得很麻烦,后来看到 NASA 说要用 py 取代 matlab,就去接触了 py。

python 那极为简洁与优美的语法给了当时的我极大的震撼,时至今日,写 py 代码对我而言依然是一种带有艺术意味的享受。


首先开宗明义的说一句:python 并不慢,至少不够慢。拿一个 web 后端来说,一台垃圾 4 核虚机,跑 4 个同步阻塞的 django,假设 django 上合理利用线程分担了阻塞操作,假设每节点每秒可以处理 50 个请求(超低估),在白天的 10 小时内就可以处理 720 万请求。而这种机器跑一天仅需要 20 块钱。


在学习 Python 以前需要强调的是:基础语法非常重要。虽然我们都不推崇过多的死记硬背,但是少量必要的死背是以后所有复杂思维活动的基础,就像五十音对于日语,通假字和常用动名词对于文言文,你不会就是不行。

一般认为,这包括数据类型(值/引用)、作用域(scope)、keyword、builtin 函数等


关于 Python 版本的选择,很多公司老项目依然在用 2.6、2.7,新项目的话建议至少选择 3.6(拥有稳定的 asyncio)。

  • 从 2.7 到 3.4 https://blog.laisky.com/p/whats-new-in-python3-4/
  • 从 3.4 到 3.5 https://blog.laisky.com/p/whats-new-in-python3-5/
  • 从 3.5 到 3.6 https://blog.laisky.com/p/whats-new-in-python3-6/
  • 从 3.6 到 3.7 https://docs.python.org/zh-cn/3/whatsnew/3.7.html

关于版本最后在说几点,建议在本地和服务器上都通过 pyenv 来管理版本,而不要去动系统自带的 python(以免引起额外的麻烦) https://blog.laisky.com/p/pyenv/

另外一点就是,如果你想写一个兼容 2、3 的工具包,你可以考虑使用 future http://python-future.org/compatible_idioms.html

最后提醒一下,2to3 这个脚本是有可能出错的。


学完基础就可以开始动手写代码了,这时候应该谨记遵守一些“通行规范”,几年前给公司内分享时做过一个摘要:

  • 风格指引 https://laisky.github.io/style-guide-cn/style-guides/source-code-style-guides/
  • 一些注意事项 https://laisky.github.io/style-guide-cn/style-guides/consensuses/

有了一定的实践经验后,你应该学习更多的包来提高自己的代码水平。

  • 值得学习的内建包 https://pymotw.com/3/
  • 值得了解的第三方包 https://github.com/vinta/awesome-python

因为 py 的哲学(import this)建议应该有且仅有一个完美的方式做一件事,所以建议优先采用且完善既有项目而不建议过多的造轮子。


一个小插曲,写这段的 Tim Peters 就是发明 timsort 的那位。

https://en.wikipedia.org/wiki/Tim_Peters_(software_engineer)


有空时候,建议尽可能的完整读教材和文档,建立系统性的知识体系,这可以极大的提升你的眼界和思维能力。我自己读过且觉得值得推荐的针对 py 的书籍有:

  • https://docs.python.org/3/
  • learning python
  • 核心编程
  • 改进Python的91个建议
  • Python高手之路
  • Python源码剖析
  • 数据结构与算法:Python语言描述

如果你真的很喜欢 Python 的话,那我觉得你应该也会喜欢阅读 PEP,记得几年前我只要有空就会去翻阅 PEP,这相当于是 Py 的 RFC,里面记录了几乎每一项语法的设计理念与目的。我特别喜欢的 PEP 有:

  • 8
  • 3148
  • 380
  • 484 & 3107
  • 492: async
  • 440
  • 3132
  • 495 你甚至能学到历史知识


以前听别人讲过一个比喻,静态语言是吃冒菜,一次性烫好。而动态语言是涮火锅,吃一点涮一点。

那么我觉得,GIL 就是仅有一双筷子的火锅,即使你菜很多,一次也只能涮一个。

但是,对于 I/O bound 的操作,你不必一直夹着菜,而是可以夹一些扔到锅里,这样就可以同时涮很多,提高并行效率。


GIL 在一个进程内,解释器仅能同时解释执行一条语句,这为 py 提供了天然的语句级线程安全,从很多意义上说,这都极大的简化了并行编程的难度。对于 I/O 型应用,多线程并不会受到多大影响。对于 CPU 型应用,编写一个基于 Queue 的多进程 worker 其实也就是几行的事。

(订正:应为伪指令级的线程安全)

 
from time import sleep
from concurrent.futures import ProcessPoolExecutor, wait
from multiprocessing import Manager, Queue


N_PARALLEL = 5


def worker(i: int, q: Queue) -> None:
print(f'worker {i} start')
while 1:
data = q.get()
if data is None: # 采用毒丸(poison pill)方式来结束进程池
q.put(data)
print(f'worker {i} exit')
return

print(f'dealing with data {data}...')
sleep(1)




def main():
executor = ProcessPoolExecutor(max_workers=N_PARALLEL) # 控制并发量
with Manager() as manager:
queue = manager.Queue(maxsize=50) # 控制缓存量

workers = [executor.submit(worker, i, queue) for i in range(N_PARALLEL)]
for i in range(50):
queue.put(i)

print('all task data submitted')

queue.put(None)
wait(workers)
print('all done')


main()


我经常给新人讲,是否能谨慎的对待并行编程,是一个区分初级和资深后端开发的分水岭。业界有一句老话:“没有正确的并行程序,只有不够量的并行度”,由此可见并行开发的复杂程度。

我个人认为思考并行时主要是在考虑两个问题:同步控制和资源用量。


对于同步控制,你在 thread, multiprocessing, asyncio 几个包里都会发现一系列的工具:

  • Lock 互斥锁
  • RLock 可重入锁
  • Que极彩在线-Python 从业十年是种什么体会?老程序员的一篇万字经历共享ue 队列
  • Condition 条件锁
  • Event 事件锁
  • Semaphore 信号量

这个就不展开细谈了,属于另一个语言无关的大领域。(以前写过一个很简略的简介:并行编程中的各种锁(https://blog.laisky.com/p/concurrency-lock/))


对于资源控制,一般来说主要就是两个地方:

  • 缓存区有多大(Queue 长度)
  • 并发量有多大(workers 数量)

一般来说,前者直接确定了你内存的消耗量,最好选择一个恰好或略高于消费量的数。后者一般直接决定了你的 CPU 使用率,过高的并发量会增加切换开销,得不偿失。


既然提到了 workers,稍微简单展开一下“池”这个概念。我们经常提到线程池、进程池、连接池。说白了就是对于一些可重用的资源,不必每次都创建新的,而是使用完毕后回收留待下一个数据继续使用。比如你可以选择不断地开子线程,也可以选择预先开好一批线程,然后通过 queue 来不断的获取和处理数据。


所以说使用“池”的主要目的就是减少资源的消耗。另一个优点是,使用池可以非常方便的控制并发度(很多新人以为 Queue 是用来控制并发度的,这是错误的,Queue 控制的是缓存量)。

对于连接池,还有另一层好处,那就是端口资源是有限的,而且回收端口的速度很慢,你不断的创建连接会导致端口迅速耗尽。


这里做一个用语的订正。Queue 控制的应该是缓冲量(buffer),而不是缓存量(cache)。一般来说,我们习惯上将写入队列称为缓冲,将读取队列称为缓存(有极彩在线-Python 从业十年是种什么体会?老程序员的一篇万字经历共享源)。


对前面介绍的 python 中进程/线程做一个小结,线程池可以用来解决 I/O 的阻塞,而进程可以用来解决 GIL 对 CPU 的限制(因为每一个进程内都有一个 GIL)。所以你可以开 N 个(小于等于核数)进程池,然后在每一个进程中启动一个线程池,所有的线程池都可以订阅同一个 Queue,来实现真正的多核并行。


非常简单的描述一下进程/线程,对于操作系统而言,可以认为进程是资源的最小单位(在 PCB 内保存如图 1 的数据)。而线程是调度的最小单位。同一个进程内的线程共享除栈和寄存器外的所有数据。

所以在开发时候,要小心进程内多线程数据的冲突,也要注意多进程数据间的隔离(需要特别使用进程间通信)

  • 操作系统笔记:进程(https://blog.laisky.com/p/os-process/)
  • 操作系统笔记:调度(https://blog.laisky.com/p/os-scheduler/)

再简单的补充一下,进程间通信的手段有:管道、信号、消息队列、信号量、共享内存和套接字。不过在 Py 里,单机上最常用的进程间通信就是 multiprocessing 里的 Queue 和 sharedctypes。

顺带一提,因为 CPython 的 refcnt 机制,所以 COW(copy on write)并不可靠。


人们在见到别人的“错误写法”时,倾向于无视或吐槽讽刺。但是这个行为除了让自己爽一下外没有任何意义,不懂的还是不懂,最后真正发挥影响的还是那些能够描绘一整条学习路径的方法。

我一直希望能看到一个“朴素诚恳”的切合工程实践的教程,而不是网上流传的入门大全和网课兜售骗钱的框架调参速成。


关于进程间的内存隔离,补充一个简单直观的例子。可以看到普通变量 normal_v 在两个子进程内变成了两个独立的变量(都输出 1),而共享内存的 shared_v 仍然是同一个变量,分别输出了 1 和 2。

 
from time import sleep
from concurrent.futures import ProcessPoolExecutor, wait
from multiprocessing import Manager, Queue
from ctypes import c_int64


def worker(i, normal_v, shared_v):
normal_v += 1 # 因为进程间内存隔离,所以每个进程都会得到 1
shared_v.value += 1 # 因为使用了共享内存,所以会分别得到 1 和 2

print(f'worker[{i}] got normal_v {normal_v}, shared_v {shared_v.value}')


def main():
executor = ProcessPoolExecutor(max_workers=2)
with Manager() as manager:
lock = manager.Lock()
shared_v = manager.Value(c_int64, 0, lock=lock)
normal_v = 0

workers = [executor.submit(worker, i, normal_v, shared_v) for i in range(2)]
wait(workers)
print('all done')


main()

从过去的工作经验中,我总结了一个简单粗暴的规矩:如果你要使用多进程,那么在程序启动的时候就把进程池启动起来,然后需要任何资源都请在进程内自行创建使用。如果有数据需要共享,一定要显式的采用共享内存或 queue 的方式进行传递。

见过太多在进程间共享不该共享的东西而导致的极为诡异的数据行为。


最早,一台机器从头到尾只能干一件事情。

后来,有了分时系统,我们可以开很多进程,同时干很多事。

但是进程的上下文切换开销太大,所以又有了线程,这样一个核可以一直跑一个进程,而仅需要切换进程内子线程的栈和寄存器。

直到遇到了 C10K 问题,人们发觉切换几万个线程还是挺重的,是否能更轻?


这里简单的展开一下,内存在操作系统中会被划分为内核态和用户态两部分,内核态供内核运行,用户态供普通的程序用。


应用程序通过系统 API(俗称 syscall)和内核发生交互。拿常见的 HTTP 请求来说,其实就是一次同步阻塞的 socket 调用,每次调用都会导致线程阻塞等待内核响应(内核陷入)。


而被阻塞的线程就会导致切换的发生。所以自然会问,能不能减少这种切换开销?换句话说,能不能在一个地方把事情做完,而不要切来切去的。

这个问题有两个解决思路,一是把所有的工作放进内核去做(略)。

另一个思路就是把尽可能多的工作放到用户态来做。这需要内核接口提供额外的支持:异步系统调用。


如 socket 这样的调用就支持非阻塞调用,调用后会拿到一个未就绪的 fp,将这个 fp 交给负责管理 I/O 多路复用的 selector,再注册好需要监听的事件和回调函数(或者像 tornado 一样采用定时 poll),就可以在事件就绪(如 HTTP 请求的返回已就绪)时执行相关函数。

https://github.com/tornadoweb/tornado/blob/f182隔壁老王4029db933d822f5b0d02583e4e6137f2bfd2/tornado/ioloop.py#L746


这样就可以实现在一个线程内,启动多个曾经会导致线程被切换的系统调用,然后在一个线程内监听这些调用的事件,谁先就绪就处理谁,将切换的开销降到了最小。

有一个需要特别注意的要点,你会发现主线程其实就是一个死循环,所有的调用都发生在这个循环之内。所以,你写的代码一定要避免任何阻塞。


听上去很美好,这是个万能方案吗?

很可惜不是的,最直接的一个问题是,并不是所有的 syscall 都提供了异步方法,对于这种调用,可以用线程池进行封装。对于 CPU 密集型调用,可以用进程池进行封装,asyncio 里提供了 executor 和协程进行联动的方法,这里提供一个线程池的简单例子,进程池其实同理。

 
from time import sleep
from asyncio import get_event_loop, sleep as asleep, gather, ensure_future
from concurrent.futures import ThreadPoolExecutor, wait, Future
from functools import wraps


executor = ThreadPoolExecutor(max_workers=10)
ioloop = get_event_loop()


def nonblocking(func) -> Future:
@wraps(func)
def wrapper(*args):
return ioloop.run_in_executor(executor, func, *args)
return wrapper


@nonblocking # 用线程池封装没法协程化的普通阻塞程序
def foo(n: int):
"""假装我是个很耗时的阻塞调用"""
print('start blocking task...')
sleep(n)
print('end blocking task')


async def coroutine_demo(n: int):
"""我就是个普通的协程"""

# 协程内不能出现任何的阻塞调用,所谓一朝协程,永世协程
# 那我偏要调一个普通的阻塞函数怎么办?
# 最简单的办法,套一个线程池…
await foo(n)


async def coroutine_demo_2():
print('start coroutine task...')
await asleep(1)
print('end coroutine task')


async def coroutine_main():
"""一般我们会写一个 coroutine 的 main 函数,专门负责管理协程"""
await gather(
coroutine_demo(1),
coroutine_demo_2()
)


def main():
ioloop.run_until_complete(coroutine_m极彩在线-Python 从业十年是种什么体会?老程序员的一篇万字经历共享ain())
print('all done')


main()
  • Python3 asyncio 简介(https://blog.laisky.com/p/asyncio/)

上面的例子全部都基于 3.7,如果你还在使用 Py2,那么你也可以通过 gevent、tornado 用上协程。

我个人倾向于 tornado,因为更为白盒,而且写法和 3 接近,如果你也赞同,那么可以试试我以前给公司写的 kipp 库,基于 tornado 封装了更多的工具。

https://github.com/Laisky/kipp/blob/2bc5bda6e7f593f89be662f46fed350c9daabded/kipp/aio/__init__.py

Gevent Demo:

 
#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
Gevent Pool & Child Tasks
=========================

You can use gevent.pool.Pool to limit the concurrency of coroutines.

And you can create unlimit subtasks in each coroutine.


Benchmark
=========

cost 2.675039052963257s for url http://httpbin.org/
cost 2.66813588142395s for url http://httpbin.org/ip
cost 2.674264907836914s for url http://httpbin.org/user-agent
cost 2.6776888370513916s for url http://httpbin.org/get
cost 3.97711181640625s for url http://httpbin.org/headers
total cost 3.9886841773986816s
"""
import time

import gevent
from gevent.pool import Pool
import gevent.monkey


pool = Pool(10) # set the concurrency limit
gevent.monkey.patch_socket()

try:
import urllib2
except ImportError:
import urllib.request as urllib2


TARGET_URLS = (
'http://httpbin.org/',
'http://httpbin.org/ip',
'http://httpbin.org/user-agent',
'http://httpbin.org/headers',
'http://httpbin.org/get',
)


def demo_child_task():
"""Sub coroutine task"""
gevent.sleep(2)


def demo_task(url):
"""Main coroutine

You should wrap your each task into one entry coroutine,
then spawn its own sub coroutine tasks.
"""
start_ts = time.time()
r = urllib2.urlopen(url)
demo_child_task()
print('cost {}s for url {}'.format(time.time() - start_ts, url))


def main():
start_ts = time.time()
pool.map(demo_task, TARGET_URLS)
print('total cost {}s'.format(time.time() - start_ts))


if __name__ == '__main__':
main()

tornado demo:

 
#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
cost 0.5578329563140869s, get http://httpbin.org/get
cost 0.5621621608734131s, get http://httpbin.org/ip
cost 0.5613000392913818s, get http://httpbin.org/user-agent
cost 0.5709919929504395s, get http://httpbin.org/
cost 0.572376012802124s, get http://httpbin.org/headers
total cost 0.5809519290924072s
"""
import time

import tornado
import tornado.web
import tornado.httpclient


TARGET_URLS = [
'http://httpbin.org/',
'http://httpbin.org/ip',
'http://httpbin.org/user-agent',
'http://httpbin.org/headers',
'http://httpbin.org/get',
]


@tornado.gen.coroutine
def demo_hanlder(ioloop):
for i, url in enumerate(TARGET_URLS):
demo_task(url, ioloop=ioloop)


@tornado.gen.coroutine
def demo_task(url, ioloop=None):
start_ts = time.time()
http_client = tornado.httpclient.AsyncHTTPClient()
r = yield http_client.fetch(url)
# r is the response object
end_ts = time.time()
print('cost {}s, get {}'.format(end_ts - 极彩在线-Python 从业十年是种什么体会?老程序员的一篇万字经历共享start_ts, url))
TARGET_URLS.remove(url)
if not TARGET_URLS:
ioloop.stop()


def main():
start_ts = time.time()
ioloop = tornado.ioloop.IOLoop.instance()
ioloop.add_future(demo_hanlder(ioloop), lambda f: None)
ioloop.start()

# total cost will equal to the longest task
print('total cost {}s'.format(time.time() - start_ts))


if __name__ == '__main__':
main()

kipp demo:

 
from time import sleep

from kipp.aio import coroutine2, run_until_complete, sleep, return_in_coroutine
from kipp.utils import ThreadPoolExecutor, get_logger


executor = ThreadPoolExecutor(10)
logger = get_logger()


@coroutine2
def coroutine_demo():
logger.info('start coroutine_demo')
yield sleep(1)
logger.info('coroutine_demo done')
yield executor.submit(blocking_func)
return_in_coroutine('yeo')


def blocking_func():
logger.info('start blocking task...')
sleep(1)
logger.info('blocking task return')
return 'hard'


@coroutine2
def coroutine_main():
logger.info('start coroutine_main')
r = yield coroutine_demo()
logger.info('coroutine_demo return: {}'.format(r))

yield sleep(1)
return_in_coroutine('coroutine_main yo')


def main():
f = coroutine_main()
run_until_complete(f)
logger.info('coroutine_main return: {}'.format(f.result()))


if __name__ == '__main__':
main()


使用 tornado 时需要注意,因为它依赖 generator 来模拟协程,所以函数无法返回,只能用 raise gen.Return 来模拟。3.4 里引入了 yield from 到 3.6 的 async/await 才算彻底解决了这个问题。还有就是小心 tornado 里的 Future 不是线程安全的。

至于 gevent,容我吐个槽,求别再提 monkey_patch 了极彩在线-Python 从业十年是种什么体会?老程序员的一篇万字经历共享…


https://docs.python.org/3/library/asyncio-task.html 官方文档对于 asyncio 的描述很清晰易懂,推荐一读。 一个小提示,async 函数被调用后会创建一个 coroutine,这时候该协程并不会运行,需要通过 ensure_future 或 create_task 方法生成 Task 后才会被调度执行。

另外,一个进程内不要创建多个 ioloop。


做一个小结,一个简单的做法是,启动程序后,分别创建一个进程池(进程数小于等于可用核数)、线程池和 ioloop,ioloop 负责调度一切的协程,遇到阻塞的调用时,I/O 型的扔进线程池,CPU 型的扔进进程池,这样代码逻辑简单,还能尽可能的利用机器性能。 一个简单的完整示例:

 
"""
✗ python process_thread_coroutine.py

[2019-08-11 09:09:37,670Z - INFO - kipp] - main running...
[2019-08-11 09:09:37,671Z - INFO - kipp] - coroutine_main running...
[2019-08-11 09:09:37,671Z - INFO - kipp] - io_blocking_task running...
[2019-08-11 09:09:37,690Z - INFO - kipp] - coroutine_task running...
[2019-08-11 09:09:37,691Z - INFO - kipp] - coroutine_error running...
[2019-08-11 09:09:37,691Z - INFO - kipp] - coroutine_error end, cost 0.00s
[2019-08-11 09:09:37,693Z - INFO - kipp] - cpu_blocking_task running...
[2019-08-11 09:09:38,674Z - INFO - kipp] - io_blocking_task end, cost 1.00s
[2019-08-11 09:09:38,695Z - INFO - kipp] - coroutine_task end, cost 1.00s
[2019-08-11 09:09:39,580Z - INFO - kipp] - cpu_blocking_task end, cost 1.89s
[2019-08-11 09:09:39,582Z - INFO - kipp] - coroutine_main got [None, AttributeError('yo'), None, None]
[2019-08-11 09:09:39,582Z - INFO - kipp] - coroutine_main end, cost 1.91s
[2019-08-11 09:09:39,582Z - INFO - kipp] - main end, cost 1.91s
"""


from time import sleep, time
from asyncio import get_event_loop, sleep as asleep, gather, ensure_future, iscoroutine
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor, wait
from functools import wraps

from kipp.utils import get_logger


logger = get_logger()


N_FORK = 4
N_THREADS = 10

thread_executor = ThreadPoolExecutor(max_workers=N_THREADS)
process_executor = ProcessPool极彩在线-Python 从业十年是种什么体会?老程序员的一篇万字经历共享Executor(max_workers=N_FORK)
ioloop = get_event_loop()


def timer(func):
@wraps(func)
def wrapper(*args, **kw):
logger.info(f"{func.__name__} running...")
start_at = time()
try:
r = func(*args, **kw)
finally:
logger.info(f"{func.__name__} end, cost {time() - start_at:.2f}s")

return wrapper


def async_timer(func):
@wraps(func)
async def wrapper(*args, **kw):
logger.info(f"{func.__name__} running...")
start_at = time()
try:
return await func(*args, **kw)
finally:
logger.info(f"{func.__name__} end, cost {time() - start_at:.2f}s")

return wrapper


@timer
def io_blocking_task():
"""I/O 型阻塞调用"""
sleep(1)


@timer
def cpu_blocking_task():
"""CPU 型阻塞调用"""
for _ in range(1 << 26):
pass


@async_timer
async def coroutine_task():
"""异步协程调用"""
await asleep(1)


@async_timer
async def coroutine_error():
"""会抛出异常的协程调用"""
raise AttributeError("yo")


@async_timer
async def coroutine_main():
ioloop = get_event_loop()
r = await gather(
coroutine_task(),
coroutine_error(),
ioloop.run_in_executor(thread_executor, io_blocking_task),
ioloop.run_in_executor(process_executor, cpu_blocking_task),
return_exceptions=True,
)
logger.info(f"coroutine_main got {r}")


@timer
def main():
get_event_loop().run_until_complete(coroutine_main())


if __name__ == "__main__":
main()


学到这一步,你已经能够熟练的运用协程、线程、进程处理不同类型的任务。接着拿上面提到的垃圾 4 核虚机举例,你现在应该可以比较轻松的实现达到 1k QPS 的服务,在白天十小时里可以处理超过一亿请求,费用依然仅 20元/天。你还有什么借口说是因为 Python 慢呢?


人们在聊到语言/框架/工具性能时,考虑的是“当程序员尽可能的优化后,工具性能会成为最终的瓶颈,所以我们一定要选一个最快的”。

但事实上是,程序员本身才是性能的最大瓶颈,而工具真正体现出来的价值,是在程序员很烂时,所能提供的兜底性能。

如果你觉得自己并不是那个瓶颈,那也没必要来听我讲了


在性能优化上有两句老话:

  • 一定要针对瓶颈做优化
  • 过早优化是万恶之源

所以我觉得要开放、冷静地看待工具的性能。在一套完整的业务系统中,框架工具往往是耗时占比最低的那个,在扩容、缓存技术如此发达的今天,你已经很难说出工具性能不够这样的话了。

成长的空间很大,多在自己身上找原因。


一个经验观察,即使在工作中不断的实际练习,对于异步协程这种全新的思维模式,从学会到能在工作中熟练运用且不犯大错,比较聪明的人也需要一个月。

换成 go 也不会好很多,await 也能实现同步写法,而且你依然需要面对我前文提到过的同步控制和资源用量两个核心问题。


简单提一下性能分析,py 可以利用 cProfile、line_profiler、memory_profiler、vprof、objgraph 等工具生成耗时、内存占用、调用关系图、火焰图等。

关于性能分析领域的更多方法论和理念,推荐阅读《性能之巅》(过去做的关于性能之巅的部分摘抄 https://twitter.com/ppcelery/status/1051832271001382912)。

必须强调:优化必须要有足够的数据支撑,包括优化前和优化后。


性能优化其实是一个非常复杂的领域,虽然上面提到的工具可以生成各式各样的看上去就很厉害的图,但是优化不是简单的你看哪慢就去改哪,而是需要有极其扎实的基础知识和全局思维的。

而且,上述工具得出的指标,在性能尚未逼近极限时,可能会有相当大的误导性,使用的时候也要小心。


有一些较为普适的经验:

  • I/O 越少越好,尽量在内存里完成
  • 内存分配越少越好,尽量复用
  • 变量尽可能少,gc 友好
  • 尽量提高局部性
  • 尽量用内建函数,不要轻率造轮子

下列方法如非瓶颈不要轻易用:

  • 循环展开
  • 内存对齐
  • zero copy(mmap、sendfile)

测试是开发人员很容易忽视的一个环节,很多人认为交给 QA 即可,但其实测试也是开发过程中的一个重要组成部分,不但可以提高软件的交付质量,还可以增进你的代码组织能力。

最常见的划分可以称之为黑盒 & 白盒,前者是只针对接口行为的测试,后者是深入了解实现细节,针对实现方式进行的针对性测试。


对 Py 开发者而言,最简单实用的工具就是 unitest.TestCase 和 pytest,在包内任何以 test*.py 命名的文件,内含 TestCase 类的以 test* 命名的方法都会被执行。

测试方法也很简单,你给定入参,然后调用想要测试的函数,然后检查其返回是否符合需求,不符合就抛出异常。

https://docs.pytest.org/en/latest/

 
"""
test_demo.py
"""

from unittest import TestCase
from typing import List

def demo(l: List[int]) -> int:
return l[0]

class DemoTestCase(TestCase):

def setUp(self):
print("first run")

def tearDown(self):
print("last run")

def test_demo(self):
data = []
self.assertRaises(IndexError, demo, data)


开始写测试后,你才会意识到你的很多函数非常难以测试。因为它们可能有嵌套调用,可能有内含状态,可能有外部依赖等等。

但是需要强调的是,这不但不是不写测试的理由,这其实正是写测试的目的!

通过努力地写测试,会强迫你开始编写精简、功能单一、无状态、依赖注入、避免链式调用的函数。


一个简单直观的“好坏对比”,链式调用的函数很难测试,它内含了太多其他函数的调用,一旦测试就变成了一个“集成测试”。而将其按照步骤一一拆分后,就可以对其进行精细化的“单元测试”,这可以契合你开发的步伐,步步为营稳步推进。

 
"""
这是很糟糕的链式调用
"""

def main():
func1()


def func1():
return func2()

def func2():
return func3()

def func3():
return "shit"



"""
这样写会好很多
"""
def step1():
return "yoo"


def step2(v):
return f"hello, {v}"


def step3(v):
return f"you know nothing, {v}"


def main():
r1 = step1()
r2 = step2(r1)
step3(r2)


顺带一提,对于一些无法绕开的外部调用,如网络请求、数据库请求。单元测试的准则之一就是“排除一切外部因素”,你不应该发起任何真正的外部调用的,因为这会引入不可控的数据。 正确做法是通过依赖注入 Mock 对象,或者通过 patch 去改写调用的接口对象。

以前写过一篇简介:https://blog.laisky.com/p/unittest-mock/


单元测试应该兼顾黑盒、白盒。你既应该编写面对接口的案例,也应该尽可能的试探内部的实现路径(增加覆盖率)。

你还可以逐渐地把线上遇到的各种 bug 都编写为案例,这些案例会成为项目宝贵的财富,为回归测试提供强有力的支持。而且有这么多测试案例提供保护,coding 的时候也会安心很多。


在单元测试的基础上,人们发展出了 TDD,但是在实践的过程中,发现有些“狡猾的”开发会针对案例的特例进行编程。 为此,人们决定应该抛弃形式,回归本源,从方法论的高度来探寻测试的道路。其中光明一方,就是 PBT,试图通过描述问题的实质,来自动生成测试案例。

一篇简介:https://blog.laisky.com/p/pbt-hypothesis/


另一个黑暗的方向就是 Fuzzing,它干脆完全忽略函数的实现,贯彻黑盒到底,通过遗传算法,随机的生成入参,以测试到宇宙尽头的决心,对函数进行死缠烂打,发掘出正常人根本想不到猜不着的犄角旮旯里的 bug。

我国绝不搞量化宽松 各方需协力应对全球性应战

2020-01-24
  • 极彩在线-国资委寻求企业专家定见 三年举动计划抓住酝酿
  •   放眼全国,像小邱这样的大学毕业生,将是多个城市争抢的对象。教育部指出,2020届高校毕业生规模预计将达到874万人,比2019年增加40万。

      在近几年的人才争夺中,以新一线城市为代表的热点地区滕子萱,普遍将关注点放在了大学生身上,陆续放宽这一群体的落户门槛,有的还给予安居补贴、购房优惠等。

      这一定程度带动了大学生的就业地选择偏好。根据麦可思研究院今年6月发布的《2019年中国大学生就业报告(就业蓝皮书)》,相比于北上广深,新一线城市的吸引力在不断增强。

      正值秋招季,21世纪经济报道记者梳理了15座新一线城市最新的大学生落户政策。根据《2019城市商业魅力排行榜》,这15座城市分别为成都、杭州、重庆、武汉、西安、苏州、天津、南京、长沙、郑州、东莞、青岛、沈阳、宁波和昆明。

      今年以来,人才争夺的势头丝毫没有减弱。截至目前,15座城市均对大学生敞开了大门,一些城市已经将落户门槛放宽至大专乃至中职毕业。

      在落户政策趋于同质化之后,各个新一线城市几乎又站到了同一起点,对于即将毕业的大学生们而言,下一个有吸引力的点是什么?

      落户政策有进一步放松趋势

      今年以来,部分新一线城市的落户政策又有进一步放松之势。

      春节过后,西安率先打响第一枪,本科及以上学历落户不再受年龄限制。2018年,西安就曾率先推出“面向全国在校大学生仅凭学生证和身份证即可完成在线落户”,新政实施三天的时间里,吸引了超过1.5万人迁入。

      杭州在5月发布了大学生落户细则,交1个月社保即可。2018年,在杭州以学历落户的条件需交满1年社保,同时居住满1年。

      重庆针对一般人才的落户政策姗姗来迟,但颇有一步到位的气魄。今年5月重庆提出,所有人才落户均不受在渝务工、就业年限和缴纳社保年限的限制,甚至没有年龄限制,并且直系亲属可随迁。而大学专科或具有初级专业技术职称以上的在重庆就业人员,即可纳入人才范畴。

      6月,青岛将毕业生落户门槛放宽至专科学历。

      武汉曾在2017年年初启动了 “百万大学生留汉创业就业工程”,今年7月又出引才留才新政,对专科人才及其配偶、未成年子女落户均敞开了大门。

      宁波也在7月出台了《关于进一步放宽我市户口准入条件的通知》,放宽“先落户再就业”适用人群的范畴,从原来要求的“全日制大专以上应届毕业生”,改为“毕业15年内的全日制普通高校、中等职业学校(含技校)毕业生”;专科学历或中级技能职业资格人才的落户社保缴纳年限要求,从原先的1年改为6个月。

      总体而言,新一线城市大多已经将人才落户的门槛放宽至大专生,仅天津和南京除外;西安、长沙、郑州、沈阳等更将中等职业学校(含技校)毕业的学生也纳入了可凭学历入户的群体。

      截至目前,各地政策的差异主要体现在:落户是否需要先就业,需要多久的社保缴纳证明,是否有年龄上限的限制。

      从这些指标来看,郑州和昆明最为宽松,既没有年龄方面的限制,也没有就业、缴纳社保的要求。若针对应届毕业生,不考虑年龄因素,武汉、西安、青岛、沈阳等城市也都允许大专生直接落户。

      此外,大约2/3的城市对应届大学生给予无差别的补贴。单看补助金额,郑州称得上最慷慨,博士3年的生活补贴5.4万元,并且最高可享受10万元的购房补贴。

      就业机会牵引人才流动

      在强劲的人才政策之下,新一线城市普遍迎来了常住人口的快速增长。2018年,西安、杭州、成都、重庆、郑州、长沙、宁波和武汉的常住人口增量都超过了18万。除深圳、广州和佛山之外,新增人口数量靠前的,均由新一线城市包揽。

      具体到大学生群体,上述《2019年中国大学生就业报告(就业蓝皮书)》的数据显示,北上广深就业比例持续下降,从2014届的25%下降到了2018届的21%。而新一线城市吸引力不断增强,从2014届的22%上升到了2018届的26%。在新一线城市就业的应届本科毕业生中,外地毕业生占比从2014届的28%上升到了2018届的37%。

      此外,刚毕业时在北上广深就业的毕业生中,三年内离开的比例明显上升,从2011届的18%上升到了2015届的24%。

      小邱告诉21世纪经济报道记者,从落户政策来看,很多城市看上去都差不多,补贴大多在几万元以内,是相对短期的小利益,可能对一些人有吸引力,但很难单靠此驱动大家做长期的就业决策。他身边的同学里确实有不少人考虑毕业后去新一线城市,但主要是跟就业机会结合起来,比如想做互联网的同学会更倾向于去杭州。

      在深圳一家高科技企业从事研发工作的小钟,正在考虑举家搬迁到成都,他所在的公司有到成都建研发中心的计划,小钟觉得这是个不错的机会。

      

  • 新一线城市招引大学生方针透视:大专生直接落户之后 又瞄准职校生了

    2020-01-24
  • 极彩在线-静海将打造全球智能工业立异高地

    极彩在线-静海将打造全球智能工业立异高地

    2020-01-24
  • 请关注微信公众号
    微信二维码
    不容错过
    Powered By Z-BlogPHP