外媒呼吁美国不要打压中国智能电话

在美国，消费者购买的手机主要是 iPhone 和三星手机。而这些产品往往也是在中国生产的。但是由于美国的政策，中国的华为、OPPO、小米等手机在美国的市场受到了打压，而与此同时，这些中国手机在欧洲、中东和非洲拥有大量的用户群。

外媒 ZDnet 对中国智能手机取得的技术优势表示了欣赏，比如 Oppo 在其 Find X3 Pro 屏幕上的显示屏不仅引入了 120Hz 刷新频率，而且还引入了精确的 10 位色彩表现，以及一个“微透镜”。在叹息美国消费者不能享受到这些新产品的同时，作者也认为华为和中兴的情况对多个方面都是不幸的，因为不能使用这些价格较低且极具竞争力的产品的不仅仅是消费者，还有那些试图在更多农村地区建设 5G 网络的运营商。

从全球化到对抗，受伤的不仅仅是中国人民。

AWS 可以帮你清理糟糕的 Python 代码，但是要收费

AWS 表示，其自动代码审查工具 CodeGuru 可以通过检测难以发现的缺陷来提高源代码质量，已经更新了对 Python 编程语言的支持。该服务使用 AWS 的机器学习算法来寻找应用程序开发过程中的错误，目前支持 Python 和 Java。在这个版本中，CodeGuru 增加了代码可维护性和输入验证的检测器，同时改进了资源泄漏的检测器。CodeGuru 定价是根据仓库的大小按代码行数计算的。前 10 万行代码的费用是每月 10 美元。每增加 10 万行代码，每月费用为 30 美元。

所以，代码写的烂不要紧，只要花点钱就行了。以后估计连烂代码也没得写了，AI 就可以帮你写好了。

曾经的容器编排三巨头 Mesos 项目落幕

4 月 7 日，Apache 基金会宣布开始投票，准备将 Mesos 项目移至 Attic 下。Mesos 项目起源于 Google 的数据中心资源管理系统 Borg，曾经解决了 Twitter 面临的可伸缩性和性能上的挑战。但是在后来的容器编排系统之战中，Mesos 和 Docker Swarm 不敌谷歌的 Kubernetes，纷纷落败。

Mesos 落败的原因有很多，无论是技术、战略还是大公司的倾轧，总之，短短不到十年，曾经红极一时的 Mesos 落下了帷幕。

Watchpoints 是一个简单但功能强大的工具，可以帮助你在调试 Python 时监控变量。

在调试代码时，你经常面临着要弄清楚一个变量何时发生变化。如果没有任何高级工具，那么可以选择使用打印语句在期望它们更改时输出变量。然而，这是一种非常低效的方法，因为变量可能在很多地方发生变化，并且不断地将其打印到终端上会产生很大的干扰，而将它们打印到日志文件中则变得很麻烦。

这是一个常见的问题，但现在有一个简单而强大的工具可以帮助你监控变量：watchpoints。

“监视点”的概念在 C 和 C++ 调试器中很常见，用于监控内存，但在 Python 中缺乏相应的工具。watchpoints 填补了这个空白。

安装

要使用它，你必须先用 pip 安装它：

$ python3 -m pip install watchpoints

在Python中使用 watchpoints

对于任何一个你想监控的变量，使用 watch 函数对其进行监控。

from watchpoints import watch

a = 0
watch(a)
a = 1

当变量发生变化时，它的值就会被打印到标准输出：

====== Watchpoints Triggered ======

Call Stack (most recent call last):
  <module> (my_script.py:5):
> a = 1
a:
0
->
1

信息包括：

• 变量被改变的行。
• 调用栈。
• 变量的先前值/当前值。

它不仅适用于变量本身，也适用于对象的变化：

from watchpoints import watch

a = []
watch(a)
a = {} # 触发
a["a"] = 2 # 触发

当变量 a 被重新分配时，回调会被触发，同时当分配给 a 的对象发生变化时也会被触发。

更有趣的是，监控不受作用域的限制。你可以在任何地方观察变量/对象，而且无论程序在执行什么函数，回调都会被触发。

from watchpoints import watch

def func(var):
    var["a"] = 1

a = {}
watch(a)
func(a)

例如，这段代码打印出：

====== Watchpoints Triggered ======

Call Stack (most recent call last):

  <module> (my_script.py:8):
> func(a)
  func (my_script.py:4):
> var["a"] = 1
a:
{}
->
{'a': 1}

watch 函数不仅可以监视一个变量，它也可以监视一个字典或列表的属性和元素。

from watchpoints import watch

class MyObj:
    def __init__(self):
        self.a = 0

obj = MyObj()
d = {"a": 0}
watch(obj.a, d["a"]) # 是的，你可以这样做
obj.a = 1 # 触发
d["a"] = 1 # 触发

这可以帮助你缩小到一些你感兴趣的特定对象。

如果你对输出格式不满意，你可以自定义它。只需定义你自己的回调函数：

watch(a, callback=my_callback)

# 或者全局设置

watch.config(callback=my_callback)

当触发时，你甚至可以使用 pdb：

watch.config(pdb=True)

这与 breakpoint() 的行为类似，会给你带来类似调试器的体验。

如果你不想在每个文件中都导入这个函数，你可以通过 install 函数使其成为全局：

watch.install() # 或 watch.install("func_name") ，然后以 func_name() 方式使用

我个人认为，watchpoints 最酷的地方就是使用直观。你对一些数据感兴趣吗？只要“观察”它，你就会知道你的变量何时发生变化。

尝试 watchpoints

我在 GitHub 上开发维护了 watchpoints，并在 Apache 2.0 许可下发布了它。安装并使用它，当然也欢迎大家做出贡献。

via: https://opensource.com/article/21/4/monitor-debug-python

作者：Tian Gao 选题：lujun9972 译者：geekpi 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

Jupyter 笔记本将 IPython shell 提升到一个新的高度。

Jupyter 项目最初是以 IPython 和 IPython 笔记本的形式出现的。它最初是一个专门针对 Python 的交互式 shell 和笔记本环境，后来扩展为不分语言的环境，支持 Julia、Python 和 R 以及其他任何语言。

IPython 是一个 Python shell，类似于你在命令行输入 python 或者 python3 时看到的，但它更聪明、更有用。如果你曾经在 Python shell 中输入过多行命令，并且想重复它，你就会理解每次都要一行一行地滚动浏览历史记录的挫败感。有了 IPython，你可以一次滚动浏览整个块，同时还可以逐行浏览和编辑这些块的部分内容。

它具有自动补全，并提供上下文感知的建议：

它默认会整理输出：

它甚至允许你运行 shell 命令：

它还提供了一些有用的功能，比如将 ? 添加到对象中，作为运行 help() 的快捷方式，而不会破坏你的流程：

如果你使用的是虚拟环境（参见我关于 virtualenvwrapper 的帖子），可以在环境中用 pip 安装：

pip install ipython

要在全系统范围内安装，你可以在 Debian、Ubuntu 或树莓派上使用 apt：

sudo apt install ipython3

或使用 pip：

sudo pip3 install ipython

Jupyter 笔记本

Jupyter 笔记本将 IPython shell 提升到了一个新的高度。首先，它们是基于浏览器的，而不是基于终端的。要开始使用，请安装 jupyter。

如果你使用的是虚拟环境，请在环境中使用 pip 进行安装：

pip install jupyter

要在全系统范围内安装，你可以在 Debian、Ubuntu 或树莓派上使用 apt：

sudo apt install jupyter-notebook

或使用 pip：

sudo pip3 install jupyter

启动笔记本：

jupyter notebook

这将在你的浏览器中打开：

你可以使用 “New” 下拉菜单创建一个新的 Python 3 笔记本：

现在你可以在 In[ ] 字段中编写和执行命令。使用 Enter 在代码块中换行，使用 Shift+Enter 来执行：

你可以编辑和重新运行代码块，你可以重新排序、删除，复制/粘贴，等等。你可以以任何顺序运行代码块，但是要注意的是，任何创建的变量的作用域都将根据执行的时间而不是它们在笔记本中出现的顺序。你可以在 “Kernel” 菜单中重启并清除输出或重启并运行所有的代码块。

使用 print 函数每次都会输出。但是如果你有一条没有分配的语句，或者最后一条语句没有分配，那么它总是会输出：

你甚至可以把 In 和 Out 作为可索引对象：

所有的 IPython 功能都可以使用，而且通常也会表现得更漂亮一些：

你甚至可以使用 Matplotlib 进行内联绘图：

最后，你可以保存你的笔记本，并将其包含在 Git 仓库中，如果你将其推送到 GitHub，它们将作为已完成的笔记本被渲染：输出、图形和所有一切（如 本例）：

本文原载于 Ben Nuttall 的 Tooling Tuesday 博客，经许可后重用。

via: https://opensource.com/article/21/3/ipython-shell-jupyter-notebooks

作者：Ben Nuttall 选题：lujun9972 译者：geekpi 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

VizTracer 可以跟踪并发的 Python 程序，以帮助记录、调试和剖析。

并发是现代编程中必不可少的一部分，因为我们有多个核心，有许多需要协作的任务。然而，当并发程序不按顺序运行时，就很难理解它们。对于工程师来说，在这些程序中发现 bug 和性能问题不像在单线程、单任务程序中那么容易。

在 Python 中，你有多种并发的选择。最常见的可能是用 threading 模块的多线程，用subprocess 和 multiprocessing 模块的多进程，以及最近用 asyncio 模块提供的 async 语法。在 VizTracer 之前，缺乏分析使用了这些技术程序的工具。

VizTracer 是一个追踪和可视化 Python 程序的工具，对日志、调试和剖析很有帮助。尽管它对单线程、单任务程序很好用，但它在并发程序中的实用性是它的独特之处。

尝试一个简单的任务

从一个简单的练习任务开始：计算出一个数组中的整数是否是质数并返回一个布尔数组。下面是一个简单的解决方案：

def is_prime(n):
    for i in range(2, n):
        if n % i == 0:
            return False
    return True

def get_prime_arr(arr):
    return [is_prime(elem) for elem in arr]

试着用 VizTracer 以单线程方式正常运行它：

if __name__ == "__main__":
    num_arr = [random.randint(100, 10000) for _ in range(6000)]
    get_prime_arr(num_arr)

viztracer my_program.py

调用堆栈报告显示，耗时约 140ms，大部分时间花在 get_prime_arr 上。

这只是在数组中的元素上一遍又一遍地执行 is_prime 函数。

这是你所期望的，而且它并不有趣（如果你了解 VizTracer 的话）。

试试多线程程序

试着用多线程程序来做：

if __name__ == "__main__":
    num_arr = [random.randint(100, 10000) for i in range(2000)]
    thread1 = Thread(target=get_prime_arr, args=(num_arr,))
    thread2 = Thread(target=get_prime_arr, args=(num_arr,))
    thread3 = Thread(target=get_prime_arr, args=(num_arr,))

    thread1.start()
    thread2.start()
    thread3.start()

    thread1.join()
    thread2.join()
    thread3.join()

为了配合单线程程序的工作负载，这就为三个线程使用了一个 2000 元素的数组，模拟了三个线程共享任务的情况。

如果你熟悉 Python 的全局解释器锁（GIL），就会想到，它不会再快了。由于开销太大，花了 140ms 多一点的时间。不过，你可以观察到多线程的并发性：

当一个线程在工作（执行多个 is_prime 函数）时，另一个线程被冻结了（一个 is_prime 函数）；后来，它们进行了切换。这是由于 GIL 的原因，这也是 Python 没有真正的多线程的原因。它可以实现并发，但不能实现并行。

用多进程试试

要想实现并行，办法就是 multiprocessing 库。下面是另一个使用 multiprocessing 的版本：

if __name__ == "__main__":
    num_arr = [random.randint(100, 10000) for _ in range(2000)]
   
    p1 = Process(target=get_prime_arr, args=(num_arr,))
    p2 = Process(target=get_prime_arr, args=(num_arr,))
    p3 = Process(target=get_prime_arr, args=(num_arr,))

    p1.start()
    p2.start()
    p3.start()

    p1.join()
    p2.join()
    p3.join()

要使用 VizTracer 运行它，你需要一个额外的参数：

viztracer --log_multiprocess my_program.py

整个程序在 50ms 多一点的时间内完成，实际任务在 50ms 之前完成。程序的速度大概提高了三倍。

为了和多线程版本进行比较，这里是多进程版本：

在没有 GIL 的情况下，多个进程可以实现并行，也就是多个 is_prime 函数可以并行执行。

不过，Python 的多线程也不是一无是处。例如，对于计算密集型和 I/O 密集型程序，你可以用睡眠来伪造一个 I/O 绑定的任务：

def io_task():
    time.sleep(0.01)

在单线程、单任务程序中试试：

if __name__ == "__main__":
    for _ in range(3):
        io_task()

整个程序用了 30ms 左右，没什么特别的。

现在使用多线程：

if __name__ == "__main__":
    thread1 = Thread(target=io_task)
    thread2 = Thread(target=io_task)
    thread3 = Thread(target=io_task)

    thread1.start()
    thread2.start()
    thread3.start()

    thread1.join()
    thread2.join()
    thread3.join()

程序耗时 10ms，很明显三个线程是并发工作的，这提高了整体性能。

用 asyncio 试试

Python 正在尝试引入另一个有趣的功能，叫做异步编程。你可以制作一个异步版的任务：

import asyncio

async def io_task():
    await asyncio.sleep(0.01)

async def main():
    t1 = asyncio.create_task(io_task())
    t2 = asyncio.create_task(io_task())
    t3 = asyncio.create_task(io_task())

    await t1
    await t2
    await t3

if __name__ == "__main__":
    asyncio.run(main())

由于 asyncio 从字面上看是一个带有任务的单线程调度器，你可以直接在它上使用 VizTracer：

依然花了 10ms，但显示的大部分函数都是底层结构，这可能不是用户感兴趣的。为了解决这个问题，可以使用 --log_async 来分离真正的任务：

viztracer --log_async my_program.py

现在，用户任务更加清晰了。在大部分时间里，没有任务在运行（因为它唯一做的事情就是睡觉）。有趣的部分是这里：

这显示了任务的创建和执行时间。Task-1 是 main() 协程，创建了其他任务。Task-2、Task-3、Task-4 执行 io_task 和 sleep 然后等待唤醒。如图所示，因为是单线程程序，所以任务之间没有重叠，VizTracer 这样可视化是为了让它更容易理解。

为了让它更有趣，可以在任务中添加一个 time.sleep 的调用来阻止异步循环：

async def io_task():
    time.sleep(0.01)
    await asyncio.sleep(0.01)

程序耗时更长（40ms），任务填补了异步调度器中的空白。

这个功能对于诊断异步程序的行为和性能问题非常有帮助。

看看 VizTracer 发生了什么？

通过 VizTracer，你可以在时间轴上查看程序的进展情况，而不是从复杂的日志中想象。这有助于你更好地理解你的并发程序。

VizTracer 是开源的，在 Apache 2.0 许可证下发布，支持所有常见的操作系统（Linux、macOS 和 Windows）。你可以在 VizTracer 的 GitHub 仓库中了解更多关于它的功能和访问它的源代码。

via: https://opensource.com/article/21/3/python-viztracer

作者：Tian Gao 选题：lujun9972 译者：wxy 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

在本教程中，教你如何设置和使用 Pythonic 来编程。它是一个图形化编程工具，用户可以很容易地使用现成的函数模块创建 Python 程序。

然而，不像纽约证券交易所这样的传统证券交易所一样，有一段固定的交易时间。对于加密货币而言，则是 7×24 小时交易，这使得任何人都无法独自盯着市场。

在以前，我经常思考与加密货币交易相关的问题：

• 一夜之间发生了什么？
• 为什么没有日志记录？
• 为什么下单？
• 为什么不下单？

通常的解决手段是使用加密交易机器人，当在你做其他事情时，例如睡觉、与家人在一起或享受空闲时光，代替你下单。虽然有很多商业解决方案可用，但是我选择开源的解决方案，因此我编写了加密交易机器人 Pythonic。 正如去年 我写过的文章 一样，“Pythonic 是一种图形化编程工具，它让用户可以轻松使用现成的函数模块来创建 Python 应用程序。” 最初它是作为加密货币机器人使用，并具有可扩展的日志记录引擎以及经过精心测试的可重用部件，例如调度器和计时器。

开始

本教程将教你如何开始使用 Pythonic 进行自动交易。我选择 币安 Binance 交易所的 波场 Tron 与 比特币 Bitcoin 交易对为例。我之所以选择这个加密货币对，是因为它们彼此之间的波动性大，而不是出于个人喜好。

机器人将根据 指数移动平均 exponential moving averages （EMA）来做出决策。

TRX/BTC 1 小时 K 线图

EMA 指标通常是一个加权的移动平均线，可以对近期价格数据赋予更多权重。尽管移动平均线可能只是一个简单的指标，但我对它很有经验。

上图中的紫色线显示了 EMA-25 指标（这表示要考虑最近的 25 个值）。

机器人监视当前的 EMA-25 值（t0）和前一个 EMA-25 值（t-1）之间的差距。如果差值超过某个值，则表示价格上涨，机器人将下达购买订单。如果差值低于某个值，则机器人将下达卖单。

差值将是做出交易决策的主要指标。在本教程中，它称为交易参数。

工具链

将在本教程使用如下工具：

• 币安专业交易视图（已经有其他人做了数据可视化，所以不需要重复造轮子）
• Jupyter 笔记本：用于数据科学任务
• Pythonic：作为整体框架
• PythonicDaemon ：作为终端运行（仅适用于控制台和 Linux）

数据挖掘

为了使加密货币交易机器人尽可能做出正确的决定，以可靠的方式获取资产的 美国线 open-high-low-close chart （OHLC）数据是至关重要。你可以使用 Pythonic 的内置元素，还可以根据自己逻辑来对其进行扩展。

一般的工作流程：

1. 与币安时间同步
2. 下载 OHLC 数据
3. 从文件中把 OHLC 数据加载到内存
4. 比较数据集并扩展更新数据集

这个工作流程可能有点夸张，但是它能使得程序更加健壮，甚至在停机和断开连接时，也能平稳运行。

一开始，你需要 币安 OHLC 查询 Binance OHLC Query 元素和一个 基础操作 Basic Operation 元素来执行你的代码。

数据挖掘工作流程

OHLC 查询设置为每隔一小时查询一次 TRXBTC 资产对（波场/比特币）。

配置 OHLC 查询元素

其中输出的元素是 Pandas DataFrame。你可以在 基础操作 元素中使用 输入 input 变量来访问 DataFrame。其中，将 Vim 设置为 基础操作 元素的默认代码编辑器。

使用 Vim 编辑基础操作元素

具体代码如下：

import pickle, pathlib, os
import pandas as pd

outout = None

if isinstance(input, pd.DataFrame):
    file_name = 'TRXBTC_1h.bin'
    home_path = str(pathlib.Path.home())
    data_path = os.path.join(home_path, file_name)

    try:
        df = pickle.load(open(data_path, 'rb'))
        n_row_cnt = df.shape[0]
        df = pd.concat([df,input], ignore_index=True).drop_duplicates(['close_time'])
        df.reset_index(drop=True, inplace=True)
        n_new_rows = df.shape[0] - n_row_cnt
        log_txt = '{}: {} new rows written'.format(file_name, n_new_rows)
    except:
        log_txt = 'File error - writing new one: {}'.format(e)
        df = input

    pickle.dump(df, open(data_path, "wb" ))
    output = df

首先，检查输入是否为 DataFrame 元素。然后在用户的家目录（~/）中查找名为 TRXBTC_1h.bin 的文件。如果存在，则将其打开，执行新代码段（try 部分中的代码），并删除重复项。如果文件不存在，则触发异常并执行 except 部分中的代码，创建一个新文件。

只要启用了复选框 日志输出 log output ，你就可以使用命令行工具 tail 查看日志记录：

$ tail -f ~/Pythonic_2020/Feb/log_2020_02_19.txt

出于开发目的，现在跳过与币安时间的同步和计划执行，这将在下面实现。

准备数据

下一步是在单独的 网格 Grid 中处理评估逻辑。因此，你必须借助 返回元素 Return element 将 DataFrame 从网格 1 传递到网格 2 的第一个元素。

在网格 2 中，通过使 DataFrame 通过 基础技术分析 Basic Technical Analysis 元素，将 DataFrame 扩展包含 EMA 值的一列。

在网格 2 中技术分析工作流程

配置技术分析元素以计算 25 个值的 EMA。

配置技术分析元素

当你运行整个程序并开启 技术分析 Technical Analysis 元素的调试输出时，你将发现 EMA-25 列的值似乎都相同。

输出中精度不够

这是因为调试输出中的 EMA-25 值仅包含六位小数，即使输出保留了 8 个字节完整精度的浮点值。

为了能进行进一步处理，请添加 基础操作 元素：

网格 2 中的工作流程

使用 基础操作 元素，将 DataFrame 与添加的 EMA-25 列一起转储，以便可以将其加载到 Jupyter 笔记本中；

将扩展后的 DataFrame 存储到文件中

评估策略

在 Juypter 笔记本中开发评估策略，让你可以更直接地访问代码。要加载 DataFrame，你需要使用如下代码：

用全部小数位表示

你可以使用 iloc 和列名来访问最新的 EMA-25 值，并且会保留所有小数位。

你已经知道如何来获得最新的数据。上面示例的最后一行仅显示该值。为了能将该值拷贝到不同的变量中，你必须使用如下图所示的 .at 方法方能成功。

你也可以直接计算出你下一步所需的交易参数。

买卖决策

确定交易参数

如上面代码所示，我选择 0.009 作为交易参数。但是我怎么知道 0.009 是决定交易的一个好参数呢？ 实际上，这个参数确实很糟糕，因此，你可以直接计算出表现最佳的交易参数。

假设你将根据收盘价进行买卖。

回测功能

在此示例中，buy_factor 和 sell_factor 是预先定义好的。因此，发散思维用直接计算出表现最佳的参数。

嵌套的 for 循环，用于确定购买和出售的参数

这要跑 81 个循环（9x9），在我的机器（Core i7 267QM）上花费了几分钟。

在暴力运算时系统的利用率

在每个循环之后，它将 buy_factor、sell_factor 元组和生成的 profit 元组追加到 trading_factors 列表中。按利润降序对列表进行排序。

将利润与相关的交易参数按降序排序

当你打印出列表时，你会看到 0.002 是最好的参数。

交易要素和收益的有序列表

当我在 2020 年 3 月写下这篇文章时，价格的波动还不足以呈现出更理想的结果。我在 2 月份得到了更好的结果，但即使在那个时候，表现最好的交易参数也在 0.002 左右。

分割执行路径

现在开始新建一个网格以保持逻辑清晰。使用 返回 元素将带有 EMA-25 列的 DataFrame 从网格 2 传递到网格 3 的 0A 元素。

在网格 3 中，添加 基础操作 元素以执行评估逻辑。这是该元素中的代码：

实现评估策略

如果输出 1 表示你应该购买，如果输出 2 则表示你应该卖出。 输出 0 表示现在无需操作。使用 分支 Branch 元素来控制执行路径。

分支元素：网格 3，2A 位置

因为 0 和 -1 的处理流程一样，所以你需要在最右边添加一个分支元素来判断你是否应该卖出。

分支元素：网格 3，3B 位置

网格 3 应该现在如下图所示：

网格 3 的工作流程

下单

由于无需在一个周期中购买两次，因此必须在周期之间保留一个持久变量，以指示你是否已经购买。

你可以利用 栈 Stack 元素来实现。顾名思义，栈元素表示可以用任何 Python 数据类型来放入的基于文件的栈。

你需要定义栈仅包含一个布尔类型，该布尔类型决定是否购买了（True）或（False）。因此，你必须使用 False 来初始化栈。例如，你可以在网格 4 中简单地通过将 False 传递给栈来进行设置。

将 False 变量传输到后续的栈元素中

在分支树后的栈实例可以进行如下配置：

设置栈元素

在栈元素设置中，将 对输入的操作 Do this with input 设置成 无 Nothing 。否则，布尔值将被 1 或 0 覆盖。

该设置确保仅将一个值保存于栈中（True 或 False），并且只能读取一个值（为了清楚起见）。

在栈元素之后，你需要另外一个 分支 元素来判断栈的值，然后再放置 币安订单 Binance Order 元素。

判断栈中的变量

将币安订单元素添加到分支元素的 True 路径。网格 3 上的工作流现在应如下所示：

网格 3 的工作流程

币安订单元素应如下配置：

编辑币安订单元素

你可以在币安网站上的帐户设置中生成 API 和密钥。

在币安账户设置中创建一个 API 密钥

在本文中，每笔交易都是作为市价交易执行的，交易量为 10,000 TRX（2020 年 3 月约为 150 美元）（出于教学的目的，我通过使用市价下单来演示整个过程。因此，我建议至少使用限价下单。）

如果未正确执行下单（例如，网络问题、资金不足或货币对不正确），则不会触发后续元素。因此，你可以假定如果触发了后续元素，则表示该订单已下达。

这是一个成功的 XMRBTC 卖单的输出示例：

成功卖单的输出

该行为使后续步骤更加简单：你可以始终假设只要成功输出，就表示订单成功。因此，你可以添加一个 基础操作 元素，该元素将简单地输出 True 并将此值放入栈中以表示是否下单。

如果出现错误的话，你可以在日志信息中查看具体细节（如果启用日志功能）。

币安订单元素中的输出日志信息

调度和同步

对于日程调度和同步，请在网格 1 中将整个工作流程置于 币安调度器 Binance Scheduler 元素的前面。

在网格 1，1A 位置的币安调度器

由于币安调度器元素只执行一次，因此请在网格 1 的末尾拆分执行路径，并通过将输出传递回币安调度器来强制让其重新同步。

网格 1：拆分执行路径

5A 元素指向 网格 2 的 1A 元素，并且 5B 元素指向网格 1 的 1A 元素（币安调度器）。

部署

你可以在本地计算机上全天候 7×24 小时运行整个程序，也可以将其完全托管在廉价的云系统上。例如，你可以使用 Linux/FreeBSD 云系统，每月约 5 美元，但通常不提供图形化界面。如果你想利用这些低成本的云，可以使用 PythonicDaemon，它能在终端中完全运行。

PythonicDaemon 控制台

PythonicDaemon 是基础程序的一部分。要使用它，请保存完整的工作流程，将其传输到远程运行的系统中（例如，通过 安全拷贝协议 Secure Copy SCP），然后把工作流程文件作为参数来启动 PythonicDaemon：

$ PythonicDaemon trading_bot_one

为了能在系统启动时自启 PythonicDaemon，可以将一个条目添加到 crontab 中：

# crontab -e

在 Ubuntu 服务器上的 Crontab

下一步

正如我在一开始时所说的，本教程只是自动交易的入门。对交易机器人进行编程大约需要 10％ 的编程和 90％ 的测试。当涉及到让你的机器人用金钱交易时，你肯定会对编写的代码再三思考。因此，我建议你编码时要尽可能简单和易于理解。

如果你想自己继续开发交易机器人，接下来所需要做的事：

• 收益自动计算（希望你有正收益！）
• 计算你想买的价格
• 比较你的预订单（例如，订单是否填写完整？）

你可以从 GitHub 上获取完整代码。

via: https://opensource.com/article/20/4/python-crypto-trading-bot

作者：Stephan Avenwedde 选题：lujun9972 译者：wyxplus 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

字典数据结构可以帮助你快速访问信息。

字典是 Python 编程语言使用的数据结构。一个 Python 字典由多个键值对组成；每个键值对将键映射到其关联的值上。

例如你是一名老师，想把学生姓名与成绩对应起来。你可以使用 Python 字典，将学生姓名映射到他们关联的成绩上。此时，键值对中键是姓名，值是对应的成绩。

如果你想知道某个学生的考试成绩，你可以从字典中访问。这种快捷查询方式可以为你节省解析整个列表找到学生成绩的时间。

本文介绍了如何通过键访问对应的字典值。学习前，请确保你已经安装了 Anaconda 包管理器和 Jupyter 笔记本。

1、在 Jupyter 中打开一个新的笔记本

首先在 Web 浏览器中打开并运行 Jupyter。然后，

1. 转到左上角的 “File”。
2. 选择 “New Notebook”，点击 “Python 3”。

开始时，新建的笔记本是无标题的，你可以将其重命名为任何名称。我为我的笔记本取名为 “OpenSource.com Data Dictionary Tutorial”。

笔记本中标有行号的位置就是你写代码的区域，也是你输入的位置。

在 macOS 上，可以同时按 Shift + Return 键得到输出。在创建新的代码区域前，请确保完成上述动作；否则，你写的任何附加代码可能无法运行。

2、新建一个键值对

在字典中输入你希望访问的键与值。输入前，你需要在字典上下文中定义它们的含义：

empty_dictionary = {}
grades = {
    "Kelsey": 87,
    "Finley": 92
}

one_line = {a: 1, b: 2}

这段代码让字典将特定键与其各自的值关联起来。字典按名称存储数据，从而可以更快地查询。

3、通过键访问字典值

现在你想查询指定的字典值；在上述例子中，字典值指特定学生的成绩。首先，点击 “Insert” 后选择 “Insert Cell Below”。

在新单元格中，定义字典中的键与值。

然后，告诉字典打印该值的键，找到需要的值。例如，查询名为 Kelsey 的学生的成绩：

# 访问字典中的数据
grades = {
    "Kelsey": 87,
    "Finley": 92
}

print(grades["Kelsey"])
87

当你查询 Kelsey 的成绩（也就是你想要查询的值）时，如果你用的是 macOS，只需要同时按 Shift+Return 键。

你会在单元格下方看到 Kelsey 的成绩。

4、更新已有的键

当把一位学生的错误成绩添加到字典时，你会怎么办？可以通过更新字典、存储新值来修正这类错误。

首先，选择你想更新的那个键。在上述例子中，假设你错误地输入了 Finley 的成绩，那么 Finley 就是你需要更新的键。

为了更新 Finley 的成绩，你需要在下方插入新的单元格，然后创建一个新的键值对。同时按 Shift+Return 键打印字典全部信息：

grades["Finley"] = 90
print(grades)

{'Kelsey': 87; "Finley": 90}

单元格下方输出带有 Finley 更新成绩的字典。

5、添加新键

假设你得到一位新学生的考试成绩。你可以用新键值对将那名学生的姓名与成绩补充到字典中。

插入新的单元格，以键值对形式添加新学生的姓名与成绩。当你完成这些后，同时按 Shift+Return 键打印字典全部信息：

grades["Alex"] = 88
print(grades)

{'Kelsey': 87, 'Finley': 90, 'Alex': 88}

所有的键值对输出在单元格下方。

使用字典

请记住，键与值可以是任意数据类型，但它们很少是 扩展数据类型 non-primitive types 。此外，字典不能以指定的顺序存储、组织里面的数据。如果你想要数据有序，最好使用 Python 列表，而非字典。

如果你考虑使用字典，首先要确认你的数据结构是否是合适的，例如像电话簿的结构。如果不是，列表、元组、树或者其他数据结构可能是更好的选择。

via: https://opensource.com/article/21/3/dictionary-values-python

作者：Lauren Maffeo 选题：lujun9972 译者：DCOLIVERSUN 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出