今天看了这个非常棒的文章，必须要转帖过来，如有侵权，请及时告知！

链接地址

IPDB是什么？IPDB（Ipython Debugger），和GDB类似，是一款集成了Ipython的Python代码命令行调试工具，可以看做PDB的升级版。这篇文章总结IPDB的使用方法，主要是若干命令的使用。更多详细的教程或文档还请参考Google。

安装与使用

IPDB以Python第三方库的形式给出，使用pip install ipdb即可轻松安装。

在使用时，有两种常见方式。

集成到源代码中

通过在代码开头导入包，可以直接在代码指定位置插入断点。如下所示：

1
2
3
4
5
6

import ipdb
# some code
x = 10
ipdb.set_trace()
y = 20
# other code

则程序会在执行完x = 10这条语句之后停止，展开Ipython环境，就可以自由地调试了。

命令式

上面的方法很方便，但是也有不灵活的缺点。对于一段比较棘手的代码，我们可能需要按步执行，边运行边跟踪代码流并进行调试，这时候使用交互式的命令式调试方法更加有效。启动IPDB调试环境的方法也很简单：

1

python -m ipdb your_code.py

常用命令

IPDB调试环境提供的常见命令有：

帮助

帮助文档就是这样一个东西：当你写的时候觉得这TM也要写？当你看别人的东西的时候觉得这TM都没写？

使用h即可调出IPDB的帮助。可以使用help command的方法查询特定命令的具体用法。

下一条语句

使用n(next)执行下一条语句。注意一个函数调用也是一个语句。如何能够实现类似“进入函数内部”的功能呢？

进入函数内部
使用s(step into)进入函数调用的内部。

打断点

使用b line_number(break)的方式给指定的行号位置加上断点。使用b file_name:line_number的方法给指定的文件（还没执行到的代码可能在外部文件中）中指定行号位置打上断点。

另外，打断点还支持指定条件下进入，可以查询帮助文档。

一直执行直到遇到下一个断点
使用c(continue)执行代码直到遇到某个断点或程序执行完毕。

一直执行直到返回
使用r(return)执行代码直到当前所在的这个函数返回。

跳过某段代码

使用j line_number(jump)可以跳过某段代码，直接执行指定行号所在的代码。

更多上下文

在IPDB调试环境中，默认只显示当前执行的代码行，以及其上下各一行的代码。如果想要看到更多的上下文代码，可以使用l first, second命令。

其中first指示向上最多显示的行号，second指示向下最多显示的行号（可以省略）。当second小于first时，second指的是从first开始的向下的行数（相对值vs绝对值）。

根据SO上的这个问题，你还可以修改IPDB的源码，一劳永逸地改变上下文的行数。

我在哪里

调试兴起，可能你会忘了自己目前所在的行号。例如在打印了若干变量值后，屏幕完全被这些值占据。使用w或者where可以打印出目前所在的行号位置以及上下文信息。

这是啥

我们可以使用whatis variable_name的方法，查看变量的类别（感觉有点鸡肋，用type也可以办到）。

列出当前函数的全部参数

当你身处一个函数内部的时候，可以使用a(argument)打印出传入函数的所有参数的值。

打印

使用p(print)和pp(pretty print)可以打印表达式的值。

清除断点

使用cl或者clear file:line_number清除断点。如果没有参数，则清除所有断点。

再来一次

使用restart重新启动调试器，断点等信息都会保留。restart实际是run的别名，使用run args的方式传入参数。

退出

使用q退出调试，并清除所有信息。

转自

机器学习定义

Arthur Samuel (1959). Machine Learning: Field of study that gives computers the ability to learn without being explicitly programmed.

使机器在没有明确编程上的研究领域具备学习的能力.

Tom Mitchell (1998) Well-posed Learning Problem: A computer program is said to learn from experience E with respect to some task T and some performance measure P, if its performance on T, as measured by P, improves with experience E.

对于某类任务T和性能度量P，如果一个计算机程序在T上以P衡量的性能随着经验E而自我完善，那么我们称这个计算机程序在从经验E学习.
完全为了押韵…

机器学习算法

• 监督式学习
• 非监督式学习
• 强化学习
• 推荐系统

监督式学习介绍

如图片所示，监督式学习为right answers given.．此处为regression(回归模型).

Regression: Predict continuous valued output(price)
回归: 预测一系列的值输出(价钱)

此处为Classification(分类模型),

Classification: Discrete valued output(0 or 1)
分类: 分离值输出(0或者1)

非监督式学习介绍

模型与代价函数

代价函数: 与真实的所表现出来的误差函数.

• 线性回归: liner regression
• 损失函数: cost function
• 梯度下降: gradient descent

梯度下降

强烈建议阅读:深入浅出-梯度下降法及其实现

矩阵

略.

选择

1. 加深目前的工程能力
2. 学习机器学习，并作为未来目标

学习路线

官方文档
清华源

票价40元，需要单独拉出来单列一行.

之前一直很好奇像sanic或者aiohttp是如何实现并发的，其实从网上看无非就是使用了asyncio,更底层就是事件驱动，libevent之类的，但是纯从应用层来讲，这个会是怎么一回事呢，举个例子:

1
2
3
4
5
6
7
8
9
10
11

async def worker():
    # 模拟消耗时间
    await asyncio.sleep(3)
    return "ok"

async def concurrent():
    # 模拟并发
    tasks = [worker() for _ in range(10)]
    await asyncio.gather(*tasks)
    

从上面代码来看，整个执行周期为3s,但是有个问题是：如果请求一个一个来，如何不阻塞呢？？

1
2
3
4
5
6
7
8
9
10
11
12
13

async def worker(message):
    # deal message
    await asyncio.sleep(3)
    return "result"

async def consumer():
    # 此处一下过来7条消息
    # 这里如何实现并行执行这7条消息呢？？
    # await worker(message) # ?? 这样会阻塞，并不是一旦发生阻塞就调度出去.
    # 那如果这样呢？
    asyncio.create_task(worker(message))
    # 来了消息创建一个任务，调度出去，不阻塞，这样就可以接收大量消息喽？？

如果按照例如eventlet的做法:

1
2
3
4
5
6
7
8
9

procpool = GreenPool(size=poolsize)

def worker(message):
    pass

def consumer():
    gt = procpool.spawn(worker, message)
    gt.link(handle_message_processed, message) # 此处省略

消息过来，直接抛给pool，并不会进行阻塞,并且有poolsize控制池大小，

额，这里是sanic源码中的一部分…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

# -*- coding: utf-8 -*-

"""
-------------------------------------------------
   File Name：     serve
   Description :
   Author :       yu.zhang
   date：          18-7-13
-------------------------------------------------
"""
import asyncio
from functools import partial


class EchoServer(asyncio.Protocol):
    def __init__(self, loop, connections=set()):
        self.connections = connections
        self.transport = None
        self.loop = loop

    def connection_made(self, transport):
        self.connections.add(self)
        self.transport = transport

    def connection_lost(self, exc):
        self.connections.discard(self)
        print('closed:', len(self.connections))

    def data_received(self, data):
        print(data)
        self.transport.write(data)


def serve(host, port, connections=None, protocol=EchoServer, loop=None, reuse_port=False):
    connections = connections if connections is not None else set()
    server = partial(protocol,
                     loop=loop,
                     connections=connections)

    server_coroutine = loop.create_server(server, host, port, reuse_port=reuse_port)
    try:
        echo_server = loop.run_until_complete(server_coroutine)
    except BaseException:
        return
    try:
        loop.run_forever()
    finally:
        for connection in connections:
            print(dir(connection))
        loop.run_until_complete(echo_server.wait_closed())
        loop.close()


if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    serve('127.0.0.1', 8080, loop=loop)