Quantinsti-博客中文翻译-五-

Quantinsti 博客中文翻译（五）

原文：Quantinsti Blog

协议：CC BY-NC-SA 4.0

冠状病毒的心理背景及其跨资产类别的溢出

原文：https://blog.quantinsti.com/psychological-backdrop-coronavirus-spillover-asset-classes-unicom/

此活动已经结束。

日期:2020 年 6 月 10 日

时间:英国夏令时 15:30/美国东部时间 10:30/IST 时间 20:00

恐惧、贪婪和非理性繁荣——冠状病毒的心理背景：它对资产类别的溢出效应

关于在线会话

为了应对新冠肺炎事件造成的中断，联通已经计划了一系列在线小组会议，届时领先的学科专家/权威人士将出席并举行小组讨论。

会议持续时间约为 60-75 分钟，并有额外的问答时间

这些会议以互动的形式进行，为所有远程与会者提供了物理会议的数字体验。在这里，代表们积极参与，通过问答交流，在会议期间和休息时间分别与同行和小组成员交流。

涵盖的主题

  • 股票的早期复苏:为什么？
  • 各国央行的反应:趋同还是趋异？
  • 对主权债务和公司债务的影响
  • 数字服务的意外崛起
  • 共同损害
  • 油价和其他商品价格暴跌
  • 偶然发现大公司的 ESG 和 SRI 档案

主讲人

小组主持人

小组成员

从追求兴趣到提高算法交易技巧——Chamundeswari 的故事

原文：https://blog.quantinsti.com/pursuing-interest-enhancing-skills-algorithmic-trading-chamundeswari/

你是一个追求刺激的算法交易者吗？

你成为 T3 是因为你发现它真的很有趣，想在其中建立自己的事业吗？你遇到过会大声回答“是”的人吗？如果你还没有见过他们，这里有一个人跟随了她对学习的热情和好奇心，追求她对交易的热爱。Chamundeswari Koppisetti 分享了她的故事、个人趣闻、她的职业道路和她短暂的算法交易之旅，请加入我们这个有趣的讨论。谁知道呢，也许你会把你的故事和她的联系起来——请在评论中告诉我们。

以下是我们与 Chamundeswari 的对话。

chamundeswari-koppisetti-pic

你好，Chamundeswari！告诉我们你自己的情况

嗨，我是 Chamundeswari Koppisetti 。我在 BITS Pilani 获得了金融学士学位，并在金融行业工作了 4 年。我有多方面的技能，我喜欢冒险。我喜欢走人迹罕至的路。

我是一个运动爱好者。除了对户外运动感兴趣，我还喜欢解数独谜题，喜欢挑战智力的纸牌游戏和棋盘游戏。每当我赢得一场比赛，我的快乐就会加倍。这为我奠定了交易和市场的基础。在报纸上读到，我发现股票市场是一个零和游戏，我开始交易时认为它很有趣，我可以赚些钱。我的数学技能和对了解市场的浓厚兴趣帮助我认识到投资的风险和可能性。

你一直渴望成为算法交易领域的一员吗？

从我获得校园实习开始，我就对这个行业感兴趣，并且一直到现在。我每天跟踪市场，不管是否需要交易。随着我成为一名交易员的热情，我在瑞士再保险公司找到了一份交易员的工作，还有一份战略和运营的工作。我在一家投资银行和一家再保险公司的工作经历帮助我实际运用了我在学校学到的知识。

现在，带着在算法交易行业取得成功的明确目标，我打算去康涅狄格大学攻读应用金融数学硕士学位。

你采取了哪些步骤来学习算法交易？

在我担任固定收益交易员期间，经过几次执行后，我开始思考是否可以设计算法来运行和寻找固定收益领域的机会主义投资。为此，我觉得有必要提高我在编程、统计、市场微观结构等方面的技能。深入了解算法交易领域。进来吧，EPAT。

你自豪地获得了 EPAT 颁发的优秀证书。你和 EPAT 相处得怎么样？

作为 quantin STI EPAT 项目的一部分，我有一段很棒的经历，特别是在了解机器学习功能方面。例如，如何使用强化算法来下订单等。校友和教师给我留下了深刻的印象，他们都是从业者，在业内非常有名。我真的很钦佩欧内斯特·陈博士——以前经常读他的书和文章。

在 EPAT 获得的技能对你的职业生涯有什么帮助？

我想探索算法交易的世界，这让我加入了 EPAT。EPAT 帮助我磨练了统计、微积分和编程方面的技能。由于我打算继续深造，希望在算法交易领域出类拔萃，这些技能对我来说会非常有用。

你认为什么样的技能是一个人在算法交易中发展职业生涯所必需的？

我觉得以下技能是必要的:

  • 对市场的了解
  • 概率与统计
  • 结石
  • 小编程

如果你擅长数学，你也可以自学这些。

对有抱负的算法交易者有什么话要说吗？

聪明数学强

谢谢分享，Chamundeswari，祝你前程似锦。

EPAT 通过其全面的课程和实践培训，帮助任何希望进入算法交易和量化交易领域的人，让他们具备在这一领域取得成功所需的技能和知识。在此报名参加EPAT。

免责声明:为了帮助正在考虑从事算法和量化交易的个人，本案例研究是根据 QuantInsti EPAT项目的学生或校友的个人经历整理的。案例研究仅用于说明目的，并不意味着用于投资目的。EPAT 项目完成后所取得的成果对所有人来说可能并不一致。

学习 Algo Trading 的不懈追求如何帮助了绿诺科技

原文：https://blog.quantinsti.com/pursuit-learn-algo-trading-rino/

创业是一大成就。一个人面临许多挑战，但却得到了令人满意和充实的经历。如果我们告诉你，有人已经经历了多次创业冒险，没有放弃他的兴趣，并准备继续挑战他在算法交易领域的知识，会怎么样？

里诺·希尔曼是 EPAT 大学的校友，他的旅程和他一样有趣。简单，中肯，清晰。

这是我们和绿诺科技的对话:

告诉我们你自己的情况

我叫里诺·希尔曼，来自雅加达。我是密歇根州立大学 2005 届工程毕业生，获得了机械工程学士学位。

我的大部分职业生涯都与创业有关。我有几笔涉及制造、采购和一些互联网技术的生意。最终，我决定与生产医院家具的家族公司一起进行商业冒险。

在我的私人时间，我喜欢阅读。我对经济、政治、历史和哲学感兴趣。由此，我觉得资本市场的交易适合我的爱好。

你能分享一下你的交易经验吗？

我在业余时间交易货币。我喜欢货币市场的灵活性，因为它每周 24/5 开放。有了正确的策略，我有足够的机会发现外汇市场可以成为一个有利可图的交易场所。

我更好奇我的交易策略是否可以自动化，因为这可以给我的系统带来更大的可靠性和灵活性。我打算掌握算法交易规则。我想找到并建立正确的系统，最重要的是自动交易策略。这些是我试图解决的问题。这就是我进入算法交易的原因。

我以前对算法交易只有基本的了解，这让我对它有了更多的了解。

学习算法交易参考了哪些资源？

我会继续参加在线课程，作为我算法交易教育的补充。我对 Metatrader 4 和外汇交易的熟悉对我很有帮助。我通过定期在网上阅读几篇关于算法交易的文章来跟上这个领域的发展——我今天仍然这样做。

我的算法交易背景处于新手水平。我已经安装了' miniconda '，对 Jupyter Notebook 及其使用和编码有所了解。

为了学习算法交易，我更喜欢看书。我读了 Yves Hilpisch 博士(被誉为 Python 大师，也是作家)、Ernest Chan 博士(业内知名人士，也是作家)和其他一些著名的 algo 交易专家的几本书。幸运的是，他们是 quantin STI EPAT 课程的教员。

能够建立我自己的算法交易系统和业务是我参加这个项目的主要目的，我希望 EPAT 能给我一个关于算法交易学科的全面而深入的教育。

在今天的算法交易中，自动化和编程有多重要？

我相信市场运动将会变化得更快，因为这些天信息吸收得更快。因此，自动化和编程对于探索快速变化和转移以及根据快速变化的市场执行交易是必不可少的。

我在大学期间读过部分统计学，但从未在我的职业生涯中使用过。但是今天，我有点精通了。

你是如何利用你在职业生涯中发展起来的算法交易技巧的？

我已经开始开发基于我的人工交易系统的算法。我可以有把握地说，我的系统的可靠性和盈利能力都很好(典型的每个交易时段盈利 0.5%)。它仍在开发过程中，我很高兴能尽快使用该系统。

对于那些希望成为算法和量化交易领域一员的人，你有什么建议？

我相信编程的实践和对数学如统计学的透彻理解对于算法和量化交易领域是必不可少的。如果你没有编程背景，这将是一个挑战，但坚持不懈和努力工作将会给你带来显著的成果。

非常感谢你和我们分享你的成功故事。我们确信这将激励和鼓舞那些渴望成为算法交易领域一员的人。

如果你想进入算法交易和量化交易的世界，我们可以通过我们的算法交易管理课程(EPAT)来指导你，为你提供在这个领域取得成功所需的技能和知识。点击 了解更多关于 EPAT 的 。

免责声明:为了帮助那些考虑从事算法和量化交易的人，这个案例研究是根据一个学生或 QuantInsti 的 EPAT 项目的校友的个人经历整理的。案例研究仅用于说明目的，并不意味着用于投资目的。EPAT 项目完成后所取得的成果对所有人来说可能并不一致。

Rodrigo Scheuch |巴西|使用 Python 进行自动化交易策略的技术分析

原文：https://blog.quantinsti.com/python-automated-trading-strategies-quantra-success-story-rodrigo-scheuch/

各种在线资源对学习来说是一种挑战吗？
当罗德里戈渴望从互联网上免费学习时，你是否也面临过同样的困境？

Rodrigo 找到了一条出路，当他试图学习使用 Python 编程进行交易时。

他是怎么做到的？请继续阅读他用自己的话分享的内容！

大家好，

我是罗德里戈·舍赫，来自巴西圣保罗。在获得工业工程学士学位后，我又获得了公司金融硕士学位。我目前在巴西股票市场交易。

因为我已经交易了，我一直想学习 Python，目的是自动化和实现我的策略，但是时间太紧了。我是一名技术分析师，未来我想成为一名代码大师。我想在史料上检验我的想法和策略。我不打算每天花大部分时间做技术分析。

我决定抽出时间，开始在网上寻找学习资料，在那里我找到了 Quantra。我注意到 Quantra 的平台上已经有很多免费课程，这与我的学习目标相吻合。

我报名参加了“ Python for Trading: Basic ”课程，因为我想学习 Python。Python 的所有基本概念，以及像 Numpy & Pandas 这样的库，都得到了清晰的解释。这个课程也给了我一个关于蓝移的介绍，在那里我可以使用这个工具很容易地编写脚本和回溯测试我的策略。

以前，当我学习 Python 基础教程时，我发现它对我来说太复杂了。

感谢 Quantra！这使得学习过程非常简单，我也可以使用 Blueshift 执行学习。

这个课程真的帮助我理解了 python 是如何被用来制定策略和处理数据的。这给了我前进的视野，并使我能够有效地使用 Python 处理数据，尽管我参考了其他平台上的其他学习材料，但我还是无法做到这一点。

接下来，我将应用从本课程中学到的概念来熟悉 python。我真的很高兴，我想感谢整个团队创造了这个辉煌的课程，给了我学习的机会。

我希望在平台上完成其他课程后，我会到达一个更好的地方。谢谢您们。

非常感谢。我们很高兴成为您旅程的一部分，并祝您未来事业顺利。

Python for Trading: Basic 是一门详细而全面的课程，面向希望在 Python 方面打下坚实基础的初学者，学习 Python 并使用它来分析金融数据集。立即注册！

免责声明:本文提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害负责。所有信息均按原样提供。

Python 数据结构教程

原文：https://blog.quantinsti.com/python-data-structures/

杰伊·帕尔马

Python 有各种内置的数据结构，比如元组、列表、字典和集合。像变量一样，python 数据结构也用于存储值。与变量不同，它们不仅仅存储一个值，而是各种格式的值的集合。广义来说，python 数据结构分为数组、列表和文件。数组可以被认为是 python 数据结构的基本形式，而文件是存储复杂数据的更高级形式。

这篇博客文章是从 Python 基础手册中摘录的，其创建的简单目的是让读者理解 Python 语言的美丽和简单。

我们将在本 python 数据结构教程中讨论以下主题:

在我们深入 python 数据结构的世界之前，让我们看一下适用于 Python 中所有数据结构的索引和切片的概念。

索引和切片

字符串可以被认为是一系列字符。类似地，python 数据结构存储对象序列(浮点、整数、字符串等。).

考虑一个从 A 到 J 的 10 个字符的序列，其中我们为序列中的每个字面值分配一个唯一的位置。分配给每个字符的位置是一个从 0 到最后一个字符的整数序列。如下所示，它们依次递增 1。

索引 Zero one Two three four five six seven eight nine
序列 A B C D E F G H 我 J

在上面的序列中，字符A位于索引0，B位于1，C位于2，以此类推。注意指数是如何按时间顺序在每一步增加一个单位的。每当一个新字符被添加到这个序列中时，它将被添加到末尾，并被赋予下一个索引值(在上面的例子中，新字符的新索引将是10)。几乎所有的 python 数据结构都有一个定位元素的索引。

序列中的元素可以使用方括号[]来访问。它获取元素的index并返回元素本身。访问单个元素的语法如下:

sequence[i]

上述语句将从索引i处的序列中返回元素。我们可以通过以下方式使用语法[start index : end index]从序列中访问多个元素:

sequence[si : ei]

上述语句将返回从索引si开始的值，但不包括索引ei处的元素。这个操作被称为切片。例如:

sequence[0:4] will return elements from 'A' to 'D' and not up to 'E'. Element at the last index in the provided range will not be returned.

Python 还支持从序列末尾访问元素的负索引，它从-1 开始，如下所示:

索引 Zero one Two three four five six seven eight nine
序列 A B C D E F G H 我 J
负指数 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

也可以使用负索引对序列进行切片。为了访问最后一个元素，我们写

sequence[-1]

它将返回元素J。类似地，可以提供一个范围来访问多个元素。

sequence[-5:-1] will return elements from 'F' to 'I'

排列

数组可以被认为是一个容器，可以保存固定数量的相同类型的数据值。尽管与其他语言(如 C 和 Java)相比，python 中使用数组的情况较少，但大多数其他 Python 数据结构都在内部使用数组来实现它们的算法。一个数组由两部分组成，即元素和索引。

  • 元素:这些是要存储在数组中的实际数据值。
  • Index:数组中的每个元素都位于由索引描述的特定位置。Python 遵循从零开始的索引，这意味着索引总是从 0 开始。

我们可以使用内置的array模块创建一个数组。它可以按如下方式创建:

In [1]: from array import *
In [2]: arr = array('i', [2, 4, 6, 8])
In [3]: arr
Out[3]: array('i', [2, 4, 6, 8])
In [4]: type(arr)
Out[4]: array.array

在上面的 python 数据结构示例中，我们从array模块导入array方法，然后用方括号中的值2、4、6和8初始化变量arr。i代表数值的数据类型。在这种情况下，它表示一个整数。 Python 数组文档提供了 Python 中各种类型代码的更多信息。

可视化数组

上面声明的数组可以用以下方式表示:

索引 Zero one Two three
元素 Two four six eight

根据上图，以下是需要考虑的几点。

  • 索引从 0 开始。
  • 数组长度为 4，这意味着它可以存储 4 个值。
  • 数组只能保存单一数据类型的值。
  • 每个元素都可以通过它的索引来访问。

访问数组元素

我们使用切片操作来访问数组元素。使用方括号[]执行切片操作。它获取我们感兴趣的元素的索引。可以注意到，上述数组中第一个元素的索引为 0。因此，为了访问位置 3 的元素，我们使用符号arr[2]来访问它。

# Here, 2 represents the index of element 6
In [5]: arr[2]
Out[5]: 6
In [6]: arr[0]
Out[6]: 2

操纵数组

现在让我们了解一下 python 数据结构教程中不同的数组操作。array模块提供了各种各样的操作，可以根据需求来执行。我们将学习一些最常用的操作。

我们使用插入操作将一个或多个数据元素插入到数组中。根据需要，可以使用insert()方法在开头、结尾或任何给定的索引处插入一个元素。

# Inserting an element at the beginning
In [7]: arr.insert(0, 20)
In [8]: arr
Out[8]: array('i', [20, 2, 4, 6, 8])
# Inserting an element at the index 3
In [9]: arr.insert(3, 60)
In [10]: arr
Out[10]: array('i', [20, 2, 4, 60, 6, 8])

可以使用内置的remove()方法从数组中删除一个元素。

In [11]: arr.remove(20)
In [12]: arr
Out[12]: array('i', [2, 4, 60, 6, 8])
In [13]: arr.remove(60)
In [14]: arr
Out[14]: array('i', [2, 4, 6, 8])

我们可以使用赋值操作符=以如下方式更新特定索引处的元素:

# Update an element at index 1
In [15]: arr[0] = 1
In [16]: arr
Out[16]: array('i', [1, 4, 6, 8])
# Update an element at index 3
In [17]: arr[3] = 7
In [18]: arr
Out[18]: array('i', [1, 4, 6, 7])

除了上面提到的操作，array模块还提供了一堆可以在数组上执行的其他操作，如反转、弹出、追加、搜索、转换为其他类型等。更多细节可以在这里找到

虽然 Python 允许我们在数组上执行各种各样的操作，但是内置的数组模块很少使用。相反，在实际编程中，大多数程序员更喜欢使用 NumPy 库提供的 NumPy 数组。

元组

在 Python 数据结构中，元组是标准库的一部分。像数组一样，元组中也包含多个值，用逗号分隔。此外，它还允许将不同类型的值存储在一起。元组是不可变的，通常包含通过解包或索引访问的异构元素序列。

为了创建一个元组，我们将所有元素放在括号()中。与数组不同，我们不需要导入任何模块来使用元组。现在让我们看看元组 python 数据结构上的一些操作。

# Creating a tuple 'tup' with elements of the same data type
In [19]: tup = (1, 2, 3)
In [20]: tup
Out[20]: (1, 2, 3)
# Verifying the type
In [21]: type(tup)
Out[21]: tuple
# Creating a tuple 'tupl' with elements of different data types
In [22]: tupl = (1, 'a', 2.5)
In [23]: type(tupl)
Out[23]: tuple

上面创建的元组tupl可以用以下方式可视化:

索引 Zero one Two
元素 one 一个 Two point five

不使用括号也可以创建元组 python 数据结构。

# Creating a tuple without brackets
In [24]: tup = 1, 2, 3
In [25]: type(tup)
Out[25]: tuple

我们可以在一个元组中多次重复一个值，如下所示:

In [26]: tupl = (1,) * 5 # Note trailing comma
In [27]: tupl
Out[27]: (1, 1, 1, 1, 1)

访问元组元素

使用方括号[]执行的切片操作用于访问元组元素。我们传递方括号中的索引值来获取我们感兴趣的元素。像数组一样，元组 python 数据结构也有一个索引，所有元素都与特定的索引号相关联。同样，索引从“0”开始。

# Access an element at index 0
In [28]: tup[0]
Out[28]: 1
# Access an element at index 2
In [29]: tup[2]
Out[29]: 1

如果我们试图访问一个不存在的元素，Python 会抛出一个错误。换句话说，如果我们对一个不存在的索引使用切片操作，我们将得到一个错误。

In [30]: tup[3]
Traceback (most recent call last):
 File "<ipython-input-30-c965c442ca22>", line 1, in <module>
 tup[3]
IndexError: tuple index out of range

在上面的例子中，我们试图访问一个不存在的索引为3的元素。因此，Python 抛出了一个错误声明index out of range。

内置的len()函数用于检查一个元组的长度。

In [31]: len(tup)
Out[31]: 3
In [32]: len(tupl)
Out[32]: 5

不变

在 Python 数据结构中，元组对象是不可变的。也就是说，一旦创建，就不能修改。如果我们试图修改一个元组，Python 会抛出一个错误。

In [33]: tup[1] = 10
Traceback (most recent call last):
 File "<ipython-input-33-991819cff38c>", line 1, in <module>
 tup[1] = 10
TypeError: 'tuple' object does not support item assignment

不出所料，解释器抛出一个错误，将元组对象描述为不可变的。

连接元组

Python 允许我们组合两个或更多元组，或者直接将新值连接到现有元组。现在让我们看看如何连接元组 python 数据结构:

In [34]: t1 = (1, 2, 3)
In [35]: t2 = (4, 5)
In [36]: t1 + t2
Out[36]: (1, 2, 3, 4, 5)

可以使用运算符*=和+=将元组连接起来。

In [37]: t1 = (1, 2, 3)
In [38]: t1 += 4, 5
In [39]: t1
Out[39]: (1, 2, 3, 4, 5)

解包元组

在上面的一个例子中，我们遇到了语句tup = 1, 2, 3，它是元组打包的一个例子。也就是说，我们将不同的值打包成一个变量tup。相反的操作也是可能的:

In [40]: tup
Out[40]: (1, 2, 3)
In [41]: x, y, z = tup

上述语句执行解包操作。它会将值1赋给变量x、2赋给y、3赋给z。该操作要求等号左侧的变量与元组 python 数据结构中的元素一样多。

元组方法

元组是 Python 数据结构中的简单对象之一，更易于维护。只有两种方法可用于元组对象:

  • index():这个方法返回元素的索引。
In [42]: tup
Out[42]: (1, 2, 3)
In [43]: tup.index(3) # Returns the index of value '3'.
Out[43]: 2
  • count():这个方法计算一个值出现的次数。
In [44]: tup = (1, 1, 1, 1, 1)
In [45]: tup.count(1)
Out[45]: 5

元组 python 数据结构有用的一些原因如下:

  • 它们比列表更快。
  • 它们保护数据，因为它们是不可变的。
  • 它们可以用作字典上的键。

列表

一个list是一个 python 数据结构，它保存了一个有序的项目集合，也就是说，我们可以在一个列表中存储一个项目的序列。在 Python 数据结构中，列表是通过将所有项目放在由逗号分隔的方括号[]中创建的。

它可以有任意数量的项目，它们可以是不同的数据类型，并且可以通过以下方式创建:

# Empty list
In [46]: list_a = []
In [47]: list_a
Out[47]: []
# List with integers
In [48]: list_b = [1, 2, 3]
In [49]: list_b
Out[49]: [1, 2, 3]
# List with mixed data types
In [50]: list_c =[1, 2.5, 'hello']
In [51]: list_c
Out[51]: [1, 2.5, 'hello']

一个列表也可以有另一个列表作为项目。这被称为嵌套列表。

In [52]: a_list = [1, 2, 3, ['hello', 'stock'], 4.5]

访问列表项目

与任何其他 python 数据结构一样，slice 运算符用于访问列表项或一系列列表项。它可以按以下方式使用。

In [53]: stock_list = ['HP', 'GOOG', 'TSLA', 'MSFT', 'AAPL', 'AMZN', 'NLFX']
# Accessing an element at index 2
In [54]: stock_list[2]
Out[54]: 'TSLA'
# Accessing multiple elements using slicing
In [55]: stock_list[1:4]
Out[55]: ['GOOG', 'TSLA', 'MSFT']
# Accessing last element using negative index
In [56]: stock_list[-1]
Out[56]: 'NLFX'

更新列表

与元组不同，列表 python 数据结构是可变的。也就是说，我们甚至可以在内容创建之后对其进行更改。同样，切片操作在这里帮助了我们

In [57]: stock_list
Out[57]: ['HP', 'GOOG', 'TSLA', 'MSFT', 'AAPL', 'AMZN', 'NLFX']
# Updating the first element
In [58]: stock_list[0] = 'NVDA'
# Updating the last 3 elements
In [59]: stock_list[-3:] = ['AMD', 'GE', 'BAC']
In [60]: stock_list
Out[60]: ['NVDA', 'GOOG', 'TSLA', 'AMD', 'GE', 'BAC']

也可以向现有列表中添加新元素。本质上，列表是 Python 中的一个对象。因此，list 类提供了在 list 对象上使用的各种方法。有两种方法append()和extend()用于更新现有列表。

  • 方法将单个元素添加到列表的末尾。它不返回新列表，只修改原始列表。
  • 方法将 list2 中的元素添加到列表的末尾。
In [61]: stock_list
Out[61]: ['HP', 'GOOG', 'MSFT']
In [62]: stock_list.append('AMZN')
In [63]: stock_list
Out[63]: ['HP', 'GOOG', 'MSFT', 'AMZN']

在上面的例子中，我们使用append()方法添加了一个新元素。让我们向列表中添加多个元素。在 Python 数据结构中，每当我们要向任何对象添加多个文字时，我们都将其包含在列表中，即使用方括号[]。我们期望的输出是附加了所有新元素的列表。

In [64]: stock_list.append(['TSLA', 'GE', 'NLFX'])
In [65]: stock_list
Out[65]: ['HP', 'GOOG', 'MSFT', 'AMZN', ['TSLA', 'GE', 'NLFX']]

我们得到的产量没有达到我们的预期。Python 将新的元素作为一个元素添加到stock_list中，而不是添加三个不同的元素。在 lists python 数据结构中提供了extend()方法来实现这一点。

In [66]: stock_list
Out[66]: ['HP', 'GOOG', 'MSFT', 'AMZN']
In [67]: stock_list.extend(['TSLA', 'GE', 'NLFX'])
In [68]: stock_list
Out[68]: ['HP', 'GOOG', 'MSFT', 'AMZN', 'TSLA', 'GE', 'NLFX']

为了简化起见，append()方法用于向现有列表添加单个元素，它将单个元素作为参数，而extend()方法用于向现有列表添加多个元素，它将一个列表作为参数。

列表操作

列表是最通用和最常用的 python 数据结构之一。除了上面讨论的方法，我们还有其他有用的方法。其中一些列举如下:

  • insert(index, element):在给定位置插入一个项目。第一个参数是要插入的元素的索引，所以list.insert(0, element)在列表的开头插入。
# Inserting an element at index position 1.
In [69]: stock_list.insert(1, 'AAPL')
In [70]: stock_list
Out[70]: ['HP', 'AAPL', 'GOOG', 'MSFT', 'AMZN', 'TSLA', 'GE', 'NLFX']
  • remove(element):删除参数中提供的第一个值为element的项目。如果没有这样的项目，Python 将抛出一个错误。
# Removing the element 'AAPL'
In [71]: stock_list.remove('AAPL')
In [72]: stock_list
Out[72]: ['HP', 'GOOG', 'MSFT', 'AMZN', 'TSLA', 'GE', 'NLFX']
# Again removing the element 'AAPL'.
In [73]: stock_list.remove('AAPL') # This line will throw an error as there is no element 'AAPL' the list.
Traceback (most recent call last):
 File "<ipython-input-73-8af176c2bd12>", line 1, in <module>
 stock_list.remove('AAPL')
ValueError: list.remove(x): x not in list
  • pop():该函数删除并返回列表中的最后一项。如果我们提供index作为参数，它将移除列表中给定位置的项目并返回它。注意:这里提供一个参数是可选的。
# Without providing index position as an argument. Returns and removes the last element in the list.
In [74]: stock_list.pop()
Out[74]: 'NLFX'
In [75]: stock_list
Out[75]: ['HP', 'GOOG', 'MSFT', 'AMZN', 'TSLA', 'GE']

提供索引位置作为参数。返回并移除特定位置的元素。In[76]:stock _ list . pop(2)Out[76]:' MSFT ' In[77]:stock _ list Out[77]:['惠普'，'谷歌'，' AMZN '，' TSLA '，'通用电气']

  • index(element):返回参数中第一个值为element的项目的索引。如果没有这样的项目，Python 将抛出一个错误。
In [78]: stock_list.index('GOOG')
Out[78]: 1
In [79]: stock_list.index('GE')
Out[79]: 4
  • count(element):返回element在列表中出现的次数。
# Count the element 'GOOG'
In [80]: stock_list.count('GOOG')
Out[80]: 1
# Appending the same list with 'GOOG'
In [81]: stock_list.append('GOOG')
In [82]: stock_list
Out[82]: ['HP', 'GOOG', 'AMZN', 'TSLA', 'GE', 'GOOG']
# Again, counting the element 'GOOG'
In [83]: stock_list.count('GOOG')
Out[83]: 2
  • sort():调用时，该方法返回排序后的列表。排序操作将会就绪。
# Sorting the list. The same list will be updated.
In [84]: stock_list.sort()
In [85]: stock_list
Out[85]: ['AMZN', 'GE', 'GOOG', 'GOOG', 'HP', 'TSLA']
  • reverse():该方法反转列表中的元素，执行的操作将就位。
# Reversing the elements within the list.
In [86]: stock_list.reverse()
In [87]: stock_list
Out[87]: ['TSLA', 'HP', 'GOOG', 'GOOG', 'GE', 'AMZN']

堆栈和队列

list 方法使得将列表用作堆栈或队列变得非常容易。一个栈是 python 数据结构之一(虽然在 Python 中不能直接使用),其中最后添加的元素是第一个检索到的元素，也称为后进先出(LIFO) 。通过使用append()和pop()方法，可以将一个列表作为堆栈使用。为了将一个项目添加到堆栈的顶部，我们使用了append()，为了从堆栈的顶部检索一个项目，我们使用了没有显式索引的pop()。现在，我们将在 python 数据结构教程中看到一些例子:

# (Bottom) 1 -> 5 -> 6 (Top)
In [88]: stack = [1, 5, 6]
In [89]: stack.append(4) # 4 is added on top of 6 (Top)
In [90]: stack.append(5) # 5 is added on top of 4 (Top)
In [91]: stack
Out[91]: [1, 5, 6, 4, 5]
In [92]: stack.pop() # 5 is removed from the top
Out[92]: 5
In [93]: stack.pop() # 4 is removed from the top
Out[93]: 4
In [94]: stack.pop() # 6 is removed from the top
Out[94]: 6
In [95]: stack # Remaining elements in the stack
Out[95]: [1, 5]

另一种可以使用 list 方法构建的 python 数据结构是 queue ，其中添加的第一个元素是检索的第一个元素，也称为先进先出(FIFO) 。考虑一下在售票柜台排队，根据人们到达的顺序为他们提供服务，因此第一个到达的人也是第一个离开的人。

为了实现一个队列，我们需要使用collections.deque模块；然而，列表 python 数据结构在这方面效率不高，因为每次插入和删除操作都需要使用大量内存来改变每个元素的位置。

它可以使用append()和popleft()方法创建。举个例子，

# Import 'deque' module from the 'collections' package
In [96]: from collections import deque
# Define initial queue
In [97]: queue = deque(['Perl', 'PHP', 'Go'])
In [98]: queue.append('R') # 'R' arrives and joins the queue
In [99]: queue.append('Python') # 'Python' arrives and joins the queue
In [100]: queue.popleft() # The first to arrive leaves the queue
Out[100]: 'Perl'
In [101]: queue.popleft() # The second to arrive leaves the queue
Out[101]: 'PHP'
In [102]: queue # The remaining queue in order of arrival
Out[102]: deque(['Go', 'R', 'Python'])

字典

在 python 数据结构中，字典是项目的无序集合。它将数据存储在键-值对中。字典就像一本电话簿，我们可以通过知道一个人的名字来找到他/她的电话号码或联系方式，也就是说，我们将名字(按键)与相应的细节(值)联系起来。请注意，密钥必须是唯一的，就像它在电话簿中的方式一样，即我们不能有两个名字完全相同的人。

在 dictionary python 数据结构中，使用以下符号在花括号{}中指定键和值对:

dictionary = {key1 : value1, key2 : value2, key3 : value3}

注意，键值对由冒号:分隔，键值对本身由,分隔。此外，我们只能使用不可变的对象，如字符串和元组作为字典的键。字典的值可以是可变或不可变的对象。我们创建的字典 python 数据结构是dict类的实例，它们是无序的，所以添加键的顺序不一定反映它们被检索回来时的顺序。

创建和访问词典

可以使用花括号{}或方法dict()来创建字典。例如:

# Creating an empty dictionary using {}
In [103]: tickers = {}
In [104]: type(tickers)
Out[104]: dict
# Creating an empty dictionary using the dict() method
In [105]: tickers = dict()
In [106]: type(tickers)
Out[106]: dict

让我们用相同数据类型的值创建一个字典。

In [107]: tickers = {'GOOG' : 'Alphabet Inc.',
 ...: 'AAPL' : 'Apple Inc.',
 ...: 'MSFT' : 'Microsoft Corporation'}
In [108]: tickers
Out[108]:
{'GOOG': 'Alphabet Inc.',
 'AAPL': 'Apple Inc.',
 'MSFT': 'Microsoft Corporation'}

接下来，我们将创建一个包含多种数据类型的字典。

In [109]: ticker = {'symbol' : 'AAPL',
 ...: 'price' : 224.95,
 ...: 'company' : 'Apple Inc',
 ...: 'founded' : 1976,
 ...: 'products' : ['Machintosh', 'iPod', 'iPhone', 'iPad']}

我们还可以提供一个字典作为另一个字典键的值。这样的字典叫做嵌套字典。看看下面的例子:

In [110]: tickers = {'AAPL' : {'name' : 'Apple Inc.',
 ...: 'price' : 224.95
 ...: },
 ...: 'GOOG' : {'name' : 'Alphabet Inc.',
 ...: 'price' : 1194.64
 ...: }
 ...: }

字典中的键应该是唯一的。如果我们为多个对提供相同的键，Python 将忽略与键相关联的前一个值，只存储最近的值。考虑下面的例子:

In [111]: same_keys = {'symbol' : 'AAPL',
 ...: 'symbol' : 'GOOG'}
In [112]: same_keys
Out[112]: {'symbol': 'GOOG'}

在上面的例子中，Python 丢弃了值AAPL并保留了分配给同一个键的最新值。一旦我们创建了字典 python 数据结构，我们就可以在各自键的帮助下访问它们。我们使用切片操作符[]来访问这些值；然而，我们提供了一个key来获取它的值。使用上面创建的字典，我们可以通过以下方式访问值:

In [113]: ticker
Out[113]:
{'symbol': 'AAPL',
 'price': 224.95,
 'company': 'Apple Inc',
 'founded': 1976,
 'products': ['Machintosh', 'iPod', 'iPhone', 'iPad']}
In [114]: tickers
Out[114]:
{'AAPL': {'name': 'Apple Inc.', 'price': 224.95},
 'GOOG': {'name': 'Alphabet Inc.', 'price': 1194.64}}
# Accessing the symbol name
In [115]: ticker['symbol']
Out[115]: 'AAPL'
# Accessing the ticker price
In [116]: ticker['price']
Out[116]: 224.95
# Accessing the product list
In [117]: ticker['products']
Out[117]: ['Machintosh', 'iPod', 'iPhone', 'iPad']
# Accessing the item at position 2 in the product list.
In [118]: ticker['products'][2]
Out[118]: 'iPhone'
# Accessing the first nested dictionary from the 'tickers' dictionary
In [119]: tickers['AAPL']
Out[119]: {'name': 'Apple Inc.', 'price': 224.95}
# Accessing the price of 'GOOG' ticker using chaining operation
In [120]: tickers['GOOG']['price']
Out[120]: 1194.64

修改字典

字典 python 数据结构中的值可以通过使用赋值运算符=为其对应的键赋值来更新。

In [121]: ticker['price']
Out[121]: 224.95
In [122]: ticker['price'] = 226
In [123]: ticker['price']
Out[123]: 226

也可以用类似的方式添加新的键-值对。为了添加一个新元素，我们在方括号[]中写下新的key，并赋予一个新的值。例如:

In [124]: ticker['founders'] = ['Steve Jobs', 'Steve Wozniak', 'Ronald Wayne']
In [125]: ticker
Out[125]:
{'symbol': 'AAPL',
 'price': 226,
 'company': 'Apple Inc',
 'founded': 1976,
 'products': ['Machintosh', 'iPod', 'iPhone', 'iPad'],
 'founders': ['Steve Jobs', 'Steve Wozniak', 'Ronald Wayne']}

在上面的例子中，我们添加了键founders并将列表['Steve Jobs', 'Steve Wozniak', 'Ronald Wayne']指定为值。如果我们要删除字典 python 数据结构中的任何键值对，我们使用内置的del()函数如下:

In [126]: del(ticker['founders'])
In [127]: ticker
Out[127]:
{'symbol': 'AAPL',
 'price': 226,
 'company': 'Apple Inc',
 'founded': 1976,
 'products': ['Machintosh', 'iPod', 'iPhone', 'iPad']}

字典方法

dict类提供了各种方法，使用这些方法我们可以执行各种操作。除了这些方法，我们还可以使用内置的len()函数来获取字典的长度。

In [128]: len(ticker)
Out[128]: 5
In [129]: len(tickers)
Out[129]: 2

现在我们讨论 python 数据结构中由dict类提供的一些流行方法。

  • items():该方法返回一个包含调用对象中所有时间的对象。
In [130]: ticker.items()
Out[130]: dict_items([('symbol', 'AAPL'), ('price', 226), ('company', 'Apple Inc'), ('founded', 1976), ('products', ['Machintosh', 'iPod', 'iPhone', 'iPad'])])
  • keys():该方法返回调用字典中的所有键。
In [131]: ticker.keys()
Out[131]: dict_keys(['symbol', 'price', 'company', 'founded', 'products'])
  • values():该方法返回调用对象中的所有值。
In [132]: ticker.values()
Out[132]: dict_values(['AAPL', 224.95, 'Apple Inc', 1976, ['Machintosh', 'iPod', 'iPhone', 'iPad']])
  • pop():这个 python 数据结构方法弹出一个条目，它的关键字作为参数给出。
In [133]: tickers
Out[133]:
{'GOOG': 'Alphabet Inc.',
 'AAPL': 'Apple Inc.',
 'MSFT': 'Microsoft Corporation'}
In [134]: tickers.pop('GOOG')
Out[134]: 'Alphabet Inc.'
In [135]: tickers
Out[135]: {'AAPL': 'Apple Inc.', 'MSFT': 'Microsoft Corporation'}
  • copy():顾名思义，这个 python 数据结构方法将调用字典复制到另一个字典。
In [136]: aapl = ticker.copy()
In [137]: aapl
Out[137]:
{'symbol': 'AAPL',
 'price': 224.95,
 'company': 'Apple Inc',
 'founded': 1976,
 'products': ['Machintosh', 'iPod', 'iPhone', 'iPad']}
  • clear():这个方法清空调用字典。
In [138]: ticker.clear()
In [139]: ticker
Out[139]: {}
  • update():该方法允许从另一个字典添加新的密钥对值。
In [140]: ticker1 = {'NLFX' : 'Netflix'}
In [141]: ticker2 = {'AMZN' : 'Amazon'}
In [142]: new_tickers = {}
In [143]: new_tickers.update(ticker1)
In [144]: new_tickers.update(ticker2)
In [145]: new_tickers
Out[145]: {'NLFX': 'Netflix', 'AMZN': 'Amazon'}

设置

在 python 数据结构中，集合是一个无序且无索引的项目集合。它是一个集合数据类型，是可变的、可迭代的，并且不包含重复值。Python 中的集合表示集合的数学概念。

在 Python 数据结构中，使用花括号以下列方式编写集合:

In [146]: universe ={'GOOG', 'AAPL', 'NLFX', 'GE'}
In [147]: universe
Out[147]: {'AAPL', 'GE', 'GOOG', 'NLFX'}

我们不能通过引用索引(切片操作)来访问集合中的项，因为集合是无序的，项没有索引。但是我们可以使用for循环遍历所有项目。

一旦一个集合被创建，我们不能改变它的条目，但是我们可以使用add()方法添加新的条目。

In [148]: universe.add('AMZN')
In [149]: universe
Out[149]: {'AAPL', 'AMZN', 'GE', 'GOOG', 'NLFX'}

Python 不会再次添加相同的项目，也不会抛出任何错误。

In [150]: universe.add('AMZN')
In [151]: universe.add('GOOG')
In [152]: universe
Out[152]: {'AAPL', 'AMZN', 'GE', 'GOOG', 'NLFX'}

为了在集合 python 数据结构中添加多个条目，我们使用了update()方法，在列表中添加新的条目。

In [153]: universe.update(['FB', 'TSLA'])
In [154]: universe
Out[154]: {'AAPL', 'AMZN', 'FB', 'GE', 'GOOG', 'NLFX', 'TSLA'}

我们可以使用内置的len()函数来确定一个集合的长度。

In [155]: len(universe)
Out[155]: 7

要移除或删除一个项目，我们可以使用remove()或discard()设置 python 数据结构方法。举个例子，

In [156]: universe.remove('FB')
In [157]: universe.discard('TSLA')
In [158]: universe
Out[158]: {'AAPL', 'AMZN', 'GE', 'GOOG', 'NLFX'}

如果我们试图使用集合中不存在的remove()删除一个项目，Python 将抛出一个错误。

In [159]: universe.remove('FB')
Traceback (most recent call last):
 File "<ipython-input-159-3a137a1e6cce>", line 1, in <module>
 universe.remove('FB')
KeyError: 'FB'

如果我们试图丢弃一个不在集合中的项目，discard()方法不会抛出任何错误。

In [160]: universe
Out[160]: {'AAPL', 'AMZN', 'GE', 'GOOG', 'NLFX'}
In [161]: universe.discard('FB')

我们使用clear()方法清空集合。

In [162]: universe.clear()
In [163]: universe
Out[163]: set()

按照数学符号，我们可以执行集合运算，如并、交、差等。在 Python 中使用 set。让我们看看 python 数据结构教程中的一些例子:

  • 我们定义两个集合tech_stocks和fin_stocks如下:
In [164]: tech_stocks = {'AMD', 'GOOG', 'AAPL', 'WDC'}
In [165]: fin_stocks = {'BAC', 'BMO', 'JPLS'}
  • union()方法:这个集合 python 数据结构方法允许在集合之间执行联合。该操作返回两个集合中的所有元素。
# Performs the 'union` operation
In [166]: universe = tech_stocks.union(fin_stocks)
In [167]: universe
Out[167]: {'AAPL', 'AMD', 'BAC', 'BMO', 'GOOG', 'JPLS', 'WDC'} # 'universe' contains all elements of both sets
  • intersection()方法:这个集合 python 数据结构方法执行集合之间的交集。它只返回在两个集合中都可用的元素。
In [168]: universe.intersection(fin_stocks)
Out[168]: {'BAC', 'BMO', 'JPLS'} # Only elements present in the 'universe' set and 'fin_stocks` are returned
  • difference()方法:这个 sets python 数据结构方法执行差运算，返回一个包含调用对象所有元素的集合，但不包括第二个集合的元素。
In [169]: universe.difference(fin_stocks)
Out[169]: {'AAPL', 'AMD', 'GOOG', 'WDC'} # All elements of the 'universe' set is returned except elements of the 'fin_stock'
  • issubset()方法:这个 sets python 数据结构方法检查调用集合的所有元素是否存在于第二个集合中。如果调用集合是第二个集合的子集，则返回 true，否则返回 false。
In [170]: fin_stocks.issubset(universe) # True, as the 'universe' contains all elements of the 'fin_stocks'
Out[170]: True
In [171]: universe.issubset(tech_stocks) # Can you guess why it resulted in to False?
Out[171]: False
  • isdisjoint()方法:这个设置 python 数据结构的方法检查两个集合之间的交集。如果调用集合与第二个集合不相交，则返回 true，否则返回 false。
In [172]: fin_stocks.isdisjoint(tech_stocks) # True, none of the set contains any element of each other
Out[172]: True
In [173]: fin_stocks.isdisjoint(universe) # False, the 'universe' set contains elements of the 'fin_stocks' set
Out[173]: False
  • issuperset()方法:这个 sets python 数据结构方法检查调用集合是否包含第二个集合的所有元素。如果调用集合包含第二个集合的所有元素，则返回 true，否则返回 false。
In [174]: universe.issuperset(fin_stocks) # True, the 'universe' set contains all elements of the 'fin_stocks'
Out[174]: True
In [175]: universe.issuperset(tech_stocks) # True, the 'universe' set contains all elements of the 'tech_stocks'
Out[175]: True
In [176]: fin_stocks.issuperset(universe) # False, the 'fin_stocks' set does not contains all elements of the 'universe' set
Out[176]: False

结论

在本 python 数据结构教程中，我们了解到它们是编写程序的基本构件。我们还学习了数组、列表、元组、字典和集合。除了它们的用途，我们还研究了可以在这些 python 数据结构上执行的不同操作。

重申一下，Python 数据结构教程是从 Python 基础手册中摘录的，它是为这两者而创建的；刚开始使用 Python 的新手，以及有成就的交易者，他们可以在编写策略时使用它作为方便的参考。

请在下面的评论中告诉我们你是否喜欢这篇文章和任何其他反馈。

免责声明:股票市场的所有投资和交易都涉及风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。T3】

Python 数据类型和变量教程

原文：https://blog.quantinsti.com/python-data-types-variables-tutorial/

杰伊·帕尔马

简单地说，变量可以被认为是一个有名字的容器，用来保存值。变量可以接受各种格式的数据，如字符串、整数、带小数部分的数字(浮点数)等。前面提到的这些格式称为数据类型。

现在是时候更详细地研究这些概念了。在这篇博客中，我们将更详细地讨论 python 变量和 python 数据类型。这篇博客文章是从 Python 基础手册中摘录的，其创建的简单目的是让读者理解 Python 语言的美丽和简单。

我们将在这个博客中讨论以下主题。

Python 变量

用编程术语来说，python 变量是用来存储值的保留内存位置。换句话说，Python 程序中的变量为计算机处理提供了必要的数据。

在本节中，我们将学习 python 变量及其类型。让我们从创建一个变量开始。

变量声明和赋值

在 Python 中，变量不需要像许多其他编程语言那样预先声明或定义。事实上，Python 没有声明变量的命令。为了创建一个 python 变量，我们给它赋值并开始使用它。使用单个等号=进行赋值，也称为赋值运算符。当我们给一个 python 变量赋予第一个值时，它就被创建了。

# Creating a variable
In [1]: price = 226

上面的语句可以解释为 python 变量price被赋值226。它也被称为初始化变量。一旦这条语句被执行，我们就可以开始在其他语句或表达式中使用price，它的值将被替换。举个例子，

In [2]: print(price)
226 # Output

稍后，如果我们更改price的值并再次运行print语句，新值将作为输出出现。这被称为 python 变量的重声明。

In [3]: price = 230 # Assigning new value
In [4]: print(price) # Printing price
230 # Output

我们还可以将赋值操作链接到 python 变量，这使得同时为多个变量赋值成为可能。

In [5]: x = y = z = 200 # Chaining assignment operation
In [6]: print(x, y, z) # Printing all variables
200 200 200 # Output

上例所示的链式赋值同时将值200赋给 python 变量x、y和z。

Python 变量命名约定

在 python 中，我们到处都使用 Python 变量。python 变量可以有一个简称或更具描述性的名称。命名变量时应遵循以下规则列表。

  • python 变量名必须以字母或下划线字符开头。

    stock = 'AAPL' # Valid name
_name = 'AAPL' # Valid name

  • python 变量名不能以数字开头。

    1stock = 'AAPL' # Invalid name
1_stock = 'AAPL' # Invalid name

  • python 变量名只能包含字母数字字符(a-z、A-Z、0-9)和下划线(_)。

    Stock = 'AAPL' # Valid name. It starts with a capital letter.
stock_price = 226.41 # Valid name. It is a combination of alphabets and the underscore.
stock_1 = 'AAPL' # Valid name. It is a combination of alphabets and a number.
Stock_name_2 = 'MSFT' # Valid name. It is a combination of a capital letter, alphabets and a number.

  • python 变量名不能包含空格和符号，如+、-等。

    stock name = 'AAPL' # Invalid name. It cannot contain the whitespace.
stock-name = 'AAPL' # Invalid name. It cannot contain characters other than the underscore ( _ ).

  • Python 变量名区分大小写。

    STOCK = 'AAPL'
stock = 'MSFT'
Stock = 'GOOG'
# STOCK, stock and Stock all three are different variable names.

    记住在 Python 中变量名是区分大小写的。

  • Python 关键字不能用作变量名。

    str = 'AAPL' # Invalid name.
is = 'A Variable' # Invalid name.
for = 'Dummy Variable' # Invalid name.
# 'str', 'is', and 'for' cannot be used as the variable name as they are reserved keywords in Python.

以下几点是职业程序员遵循的事实上的做法。

  • 使用描述用途的名称，而不要使用假名。换句话说，应该是有意义的。

    a = 18 # Valid name but the variable does not describe the purpose.
age = 18 # Valid name which describes it suitably

  • 使用下划线字符_分隔两个单词。

    stockname = 'AAPL' # Valid name.
stock_name = 'AAPL' # Valid name. And it also provides concise readability.

  • 变量名以一个小字母开始。

    Stock_name = 'AAPL' # Valid name.
stock_name = 'AAPL' # Valid name. Additionally, it refers to uniformity with other statements.

遵守这些规则可以增加代码的可读性。请记住，这些都是很好的编码实践(推荐但绝不是必须遵循的)，您可以将其应用到任何编程语言，而不仅仅是 Python。

Python 数据类型

理解了什么是变量以及如何使用变量存储值之后，是时候学习 python 变量所包含的值的数据类型了。我们将学习 python 中内置的原始 Python 数据类型，如数字、字符串和布尔。Python 有四种基本数据类型:

  • 整数
  • 浮动
  • 线
  • 布尔代数学体系的

我们将在下面更详细地介绍这些 python 数据类型:

整数

在 python 数据类型中，整数可以被视为不带任何小数的数值。实际上是用来描述 Python 中任何一个整数如7、256、1024等。我们用一个整数值来表示一个从负无穷大到无穷大的数值数据。使用赋值运算符将这些数字赋给 python 变量。

total_output_of_dice_roll = 6
days_elapsed = 30
total_months = 12
year = 2019

我们将整数6赋给变量total_output_of_dice_roll，因为掷骰子不可能有分数输出。类似地，我们有一个值为30的变量days_elapsed，值为12的变量total_months，值为2019的变量year。

浮动

在 python 数据类型中，float 代表浮点数，实质上是一个有小数部分的数字。也可用于有理数，通常以小数结尾如6.5、100.1、123.45等。下面是一些 python 数据类型示例，其中浮点值比整数更合适。

stock_price = 224.61
height = 6.2
weight = 60.4

从统计学的角度来看，浮点值可以被认为是一个连续的值，而整数值可以相应地是一个离散的值。

通过这样做，我们可以很好地理解 python 数据类型和 python 变量名是如何结合在一起的。反过来，这可以在表达式中使用，以执行任何数学计算。

让我们简单地用变量来尝试一下作为计算器的 Python。

# Assign an integer value
In [7]: x = 2
# Assign a float value
In [8]: y = 10.0
# Addition
In [9]: print(x + y)
Out[9]: 12.0
# Subtraction
In [10]: print(x - y)
Out[10]: -8.0
# Multiplication
In [11]: print(x * y)
Out[11]: 20.0
# Division
In [12]: print(x / y)
Out[12]: 0.2
# Modulo
In [13]: print(x % y)
Out[13]: 2.0
# Exponential / Power
In [14]: print(x ** y)
Out[14]: 1024.0

请注意代码片段中描述功能的注释的精确用法。另外，请注意，输出的所有表达式的都是作为输入中使用的文字之一的 float 数，是一个 float 值。

看看上面提到的 python 数据类型的例子，试着理解代码片段。如果你能感觉到发生了什么，那很好。您已经踏上了 python 数据类型之旅的正轨。尽管如此，让我们试着理解代码，以便更加清晰。这里，我们将整数值2赋给x，将浮点值10.0赋给y。然后，我们尝试对这些定义的变量进行各种数学运算，而不是使用直接值。明显的好处是我们通过使用这些 python 变量获得的灵活性。例如，考虑这样一种情况，我们想对不同的值如3和15.0执行上述操作，我们只需分别用新值重新声明变量x和y，其余代码保持不变。

Boolean

这个内置的 python 数据类型可以有两个值之一，True或False。我们使用赋值操作符=将一个布尔值赋给变量，其方式类似于我们所看到的整型和浮点型值。例如:

In [15]: buy = True
In [16]: print(buy)
Out[16]: True
In [17]: sell = False
In [18]: print(sell)
Out[18]: False

Python 中的表达式通常在布尔上下文中计算，这意味着它们被解释为表示它们的真值。布尔表达式广泛用于逻辑条件和控制流语句中。考虑下面的例子

# Checking for equality between 1 and itself using comparison operator '=='
In [19]: 1 == 1
Out[19]: True
# Checking for equality between values 1 and -1
In [20]: 1 == -1
Out[20]: False
# Comparing value 1 with -1
In [21]: 1 > -1
Out[21]: True

上面的 python 数据类型示例是一些计算结果为True或False的最简单的布尔表达式。

我们不在引号内写True和False。写的时候需要不带引号。此外，第一个字母需要大写，其次是小写字母。以下列表不会被评估为布尔值

  • “真的”
  • 真实的
  • 真实的
  • “错误”
  • 错误的
  • 错误的

字符串

在 python 数据类型中，字符串是写在单引号'或双引号"内的字母、数字和其他字符的集合。换句话说，它是引号内的字符序列。让我们借助一些例子来理解一个字符串是如何工作的。

# Variable assignment with a string
In [22]: sample_string = '1% can also be expressed as 0.01'
# Print the variable sample_string
In [23]: sample_string
Out[23]: '1% can also be expressed as 0.01'

在上面的 python 数据类型示例中，我们定义了一个名为sample_string的字符串变量，并为其赋值'1% can also be expressed as 0.01'。有趣的是，我们使用了字母、数字和特殊字符的组合来定义变量。在 Python 中，引号内的任何东西都是字符串。考虑下面的例子，

In [24]: stock_price = '224.61'
In [25]: stock_price
Out[25]: '224.61'

我们定义变量stock_price来分配字符串值'224.61'。有趣的是，变量的输出也是一个字符串。每当数值以字符串形式给出时，Python 不会隐式转换 python 数据类型。

我们可以使用+操作符连接两个或更多的字符串。

In [26]: 'Price of AAPL is ' + stock_price
Out[26]: 'Price of AAPL is 224.61'

使用+操作符的串联操作只对字符串有效。它不适用于不同的 python 数据类型。如果我们尝试执行该操作，将会出现一个错误。

In [27]: stock_price = 224.61 # Re-declaring the variable with an integer value
In [28]: 'Price of AAPL is ' + stock_price # Error line
Traceback (most recent call last):
 File "<ipython-input-28-1c5964ef305c>", line 1, in <module>
 'Price of AAPL is ' + stock_price
TypeError: must be str, not float

正如所料，当我们试图连接一个字符串和浮点文字时，Python 抛出了一个TypeError。类似于+操作符，我们可以使用带有字符串文字的*操作符多次产生相同的字符串。

In [29]: string = 'Python! '
In [30]: string * 3
Out[30]: 'Python! Python! Python! '

在 python 数据类型中，我们可以使用 slice 操作选择一个子字符串或字符串的一部分。使用方括号[]进行切片。从字符串中切分单个元素的语法是[index]，它将在index返回一个元素。索引是指每个元素在字符串中的位置，它从 0 开始，对于每个下一个元素，它按时间顺序不断增加。

In [29]: string = 'EPAT Handbook!'
In [30]: string[0] # 0 refers to an element E
Out[30]: 'E'
In [31]: string[1] # 1 refers to an element P
Out[31]: 'P'

在上面的 python 数据类型示例中，作为第一个字符的元素E属于索引0，紧挨着E的P属于索引1，以此类推。类似地，元素b的索引将是9。您能猜出上面例子中元素k的索引吗？

要从字符串中分割出一个子串，使用的语法是[start index:end index]，它将返回从位于start index的元素开始的子串，但不包括位于end index的元素。考虑下面的 python 数据类型示例，其中我们将字符串从索引0子串到4，产生输出'EPAT'。注意索引4处的元素' '没有包含在输出中。类似地，我们对子串进行切片，如下面的 python 数据类型示例所示。

In [32]: string[0:4]
Out[32]: 'EPAT'
In [33]: string[4]
Out[33]: ' '
In [34]: string[5:13]
Out[34]: 'Handbook'
In [35]: string[13]
Out[35]: '!'

在 Python 中，我们不能对字符串中不存在的索引执行切片操作。每当遇到索引不正确的切片操作，Python 就会抛出IndexError。

In [36]: string[14]
Traceback (most recent call last):
 File "<ipython-input-36-6a6fe155a0da>", line 1, in <module>
 string[14]
IndexError: string index out of range

在上面的 python 数据类型示例中，最后一个索引是13。用索引14执行的切片操作将导致一个错误IndexError，表明我们正在寻找的索引不存在。

我们在下面列出了字符串文字的一些要点:

  • 在 Python 3.x 中，默认情况下所有字符串都是 Unicode 。
  • 可以在''或""中写入字符串。两者都工作正常。
  • 字符串是不可变的。(尽管您可以修改变量)
  • 在字符串中使用转义序列来标记新的一行，提供制表符空间，写入\字符等。

字符串上的操作

在 python 数据类型的这一节中，我们讨论一些最常见的字符串方法。一个方法就像一个函数，但是它在一个对象上运行。如果变量sample_string是一个字符串，那么代码sample_string.upper()在该字符串对象上运行upper()方法并返回结果(这种在对象上运行方法的思想是组成面向对象编程(OOP)的基本思想之一)。有些方法还将参数作为参数。我们给方法提供一个参数，作为圆括号内的自变量。

  • upper()方法:该方法返回字符串的大写版本。python 数据类型示例如下:

    In [37]: sample_string.upper()
Out[37]: 'EPAT HANDBOOK!'

  • 方法:这个方法返回字符串的小写版本。python 数据类型示例如下:

    In [38]: sample_string.lower()
Out[38]: 'epat handbook!'

  • 方法:这个方法返回一个从开始和结束都去掉了空格的字符串。python 数据类型示例如下:

    In [39]: ' A string with whitespace at both the ends. '.strip()
Out[39]: 'A string with whitespace at both the ends.'

  • isalpha()方法:如果字符串中的所有字符都是字母，这个方法返回布尔值True，否则返回False。python 数据类型示例如下:

In [40]: 'Alphabets'.isalpha()
Out[40]: True
In [41]: 'This string contains only alphabets'.isalpha()
Out[41]: False # The string under evaluation contains whitespace.

  • isdigit()方法:如果字符串中的所有字符都是数字，这个方法返回布尔值True，否则返回False。python 数据类型示例如下:

    In [42]: '12345'.isdigit()
Out[42]: True

  • startswith(argument)方法:如果字符串的第一个字符以作为参数提供的字符开始，该方法返回布尔值True，否则返回False。python 数据类型示例如下:

    In [43]: 'EPAT Handbook!'.startswith('E')
Out[43]: True

  • endswith(argument)方法:如果字符串的最后一个字符以作为参数提供的字符结尾，该方法返回布尔值True，否则返回False。python 数据类型示例如下:

    In [44]: 'EPAT Handbook!'.startswith('k')
Out[44]: False # String ends with the '!' character.

  • find(sub, start, end)方法:该方法返回子串sub在片[start:end]中找到的字符串中的最低索引。这里，参数start和end是可选的。如果没有找到sub，则返回-1。python 数据类型示例如下:

In [45]: 'EPAT Handbook!'.find('EPAT')
Out[45]: 0
In [46]: 'EPAT Handbook!'.find('A')
Out[46]: 2 # First occurrence of 'A' is at index 2.
In [47]: 'EPAT Handbook!'.find('Z')
Out[47]: -1 # We do not have 'Z' in the string.
  • replace(old, new)方法:该方法返回一个字符串的副本，其中所有出现的old都被替换为new。python 数据类型示例如下:
Out[48]: '00 01 10 11'.replace('0', '1')
Out[48]: '11 11 11 11' # Replace 0 with 1
In [49]: '00 01 10 11'.replace('1', '0')
Out[49]: '00 00 00 00' # Replace 1 with 0
  • split(delim)方法:该方法用于根据delim参数将一个字符串拆分成多个字符串。python 数据类型示例如下:
In [50]: 'AAPL MSFT GOOG'.split(' ')
Out[50]: ['AAPL', 'MSFT', 'GOOG']

这里，Python 在一个名为 List 的数据结构中输出三个字符串。python 数据类型示例如下:

  • index(character)方法:该方法返回第一次出现的character的索引。python 数据类型示例如下:
In [51]: 'EPAT Handbook!'.index('P')
Out[51]: 1

如果在字符串中找不到作为参数提供的字符，Python 将提供一个错误。

In [52]: 'EPAT Handbook!'.index('Z')
Traceback (most recent call last):
 File "<ipython-input-52-d1b3e87f78be>", line 1, in <module>
 'EPAT Handbook!'.index('Z')
ValueError: substring not found
  • 方法:这个方法返回一个大写的字符串。python 数据类型示例如下:
In [53]: 'python is amazing!'.capitalize()
Out[53]: 'Python is amazing!'
  • count(character)方法:该方法返回由character提供的参数的计数。python 数据类型示例如下:
In [54]: 'EPAT Handbook'.count('o')
Out[54]: 2
In [55]: 'EPAT Handbook'.count('a')
Out[55]: 1

type()函数

内置的type(argument)函数用于评估 python 数据类型，并返回作为参数传递的argument的类类型。该功能主要用于调试。

In [56]: type('EPAT Handbook')
Out[56]: str # A string is represented by the class 'str'.
In [57]: type(224.61)
Out[57]: float # A float literal is represented by the class 'float'.
In [58]: type(224)
Out[58]: int # An integer literal is represented by the class 'int'.
In [59]: type('0')
Out[59]: str # An argument provided is within quotation marks. Hence, it is considered as a string object represented by the class 'str'.
In [60]: type(True)
Out[60]: bool # A boolean value is represented by the class 'bool'.
In [61]: type(False)
Out[61]: bool
In [62]: type('False')
Out[62]: str # An argument is provided within a quotation mark.
In [63]: type([1, 2, 3])
Out[63]: list # An object passed as an argument belongs to the class 'list'.
In [64]: type({'key':'value'})
Out[64]: dict # An object passed as an argument belongs to the class 'dict'.
In [65]: type((1, 2, 3))
Out[65]: tuple # An object passed as an argument belongs to the class 'tuple'.
In [66]: type({1, 2, 3})
Out[66]: set # An object passed as an argument belongs to the class 'set'.

A list、dict、tuple、set是 Python 内部的原生数据结构。

Python 数据类型转换

我们经常会遇到需要改变底层数据的 python 数据类型的情况。或者我们发现我们一直在使用一个整数，而我们真正需要的是一个浮点数。在这种情况下，我们可以转换变量的 python 数据类型。如上所示，我们可以使用type()函数检查变量的数据类型。

可能有两种类型的转换:隐式称为强制，以及显式通常称为强制转换。当我们将一个变量的类型从一种改变为另一种时，这被称为类型转换。

隐式转换:这是一个自动的类型转换，Python 解释器会为我们动态处理。我们不需要为此指定任何命令或函数。看看下面的 python 数据类型示例:

In [67]: 8 / 2
Out[67]: 4.0

在作为被除数的两个整数8和作为除数的两个整数2之间执行的除法运算。数学上，我们期望输出是4——一个整数值，但是 Python 返回的输出是4.0——一个浮点值。也就是 Python 内部把一个整数4转换成浮点数4.0。

显式转换:这种类型的转换是用户自定义的。我们需要显式地更改某些文字的 python 数据类型，以使其与数据操作兼容。让我们尝试使用+操作符连接一个字符串和一个整数。

In [68]: 'This is the year ' + 2019
Traceback (most recent call last):
 File "<ipython-input-68-2bccd8d1d6de>", line 1, in <module>
 'This is the year ' + 2019
TypeError: must be str, not int

这里我们试图连接一个字符串'This is the year '和一个整数2019。这样做的时候，python 抛出了一个错误TypeError，指出不兼容的 Python 数据类型。执行两者之间连接的一种方法是将 python 数据类型2019显式转换为 string，然后执行操作。我们使用str()将整数转换成字符串。

In [68]: 'This is the year ' + str(2019)
Out[68]: 'This is the year 2019'

类似地，我们可以通过以下方式显式更改文本的 python 数据类型。

# Integer to Float conversion
In [69]: float(4)
Out[69]: 4.0
# String to Float conversion
In [70]: float('4.2')
Out[70]: 4.2
In [71]: float('4.0')
Out[71]: 4.0
# Float to Integer conversion
In [72]: int(4.0)
Out[72]: 4 # Python will drop the fractional part.
In [73]: int(4.2)
Out[73]: 4
# String to Integer conversion
In [74]: int('4')
Out[74]: 4
# Python does not convert a string literal with a fractional part, and instead, it will throw an error.
In [75]: int('4.0')
Traceback (most recent call last):
 File "<ipython-input-75-a6536d9312a9>", line 1, in <module>
 int('4.0')
ValueError: invalid literal for int() with base 10: '4.0'
# Float to String conversion
In [76]: str(4.2)
Out[76]: '4.2'
# Integer to String conversion
In [77]: str(4)
Out[77]: '4'

在上面的例子中，我们看到了如何将 python 数据类型从一种文字改变为另一种文字。同样，bool所代表的布尔型 python 数据类型也没有什么不同。我们可以将bool定型为int，就像我们对其余部分所做的那样。事实上，Python 内部将布尔值False视为0，将True视为1。

# Boolean to Integer conversion
In [64]: int(False)
Out[64]: 0
In [65]: int(True)
Out[65]: 1

也可以将整数值转换为布尔值。Python 将0转换为False，剩余的所有整数被转换为True。

# Integer to Boolean conversion
In [78]: bool(0)
Out[78]: False
In [79]: bool(1)
Out[79]: True
In [80]: bool(-1)
Out[80]: True
In [81]: bool(125)
Out[81]: True

结论

因此，我们已经熟悉了 python 变量，然后继续定义它们，理解 python 数据类型、它们的内部工作方式和类型转换。

重申一下，Python 数据类型和变量教程是从为两者创建的 Python 基础手册中摘录的；刚开始使用 Python 的初学者以及有成就的交易者可以在编写策略时将它用作方便的参考。

请在下面的评论中告诉我们你是否喜欢这篇文章和任何其他反馈。

免责声明:股票市场的所有投资和交易都涉及风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。T3】

使用散景在 Python 中实现数据可视化

原文：https://blog.quantinsti.com/python-data-visualization-using-bokeh/

一幅画胜过千言万语或者一百年前一个聪明的女人说过。忠实于习语的每一句话，视觉化的美丽在于它可以多么清晰地传达多种信息。数据可视化是数据科学家的关键职能之一，解码视觉信息对算法交易者至关重要。这些模式(隐藏的和显而易见的)对交易者和分析师至关重要，因为他们根据这些解释决定他们的交易策略和下一步行动。

Python 提供了创建吸引人的情节和图形的酷方法。一些受欢迎的软件包包括 Matplotlib、Bokeh、T2、Plotly 和 Seaborn。在这篇博文中，我们将探索 Bokeh，这是一个 Python 交互式可视化库，使用现代 web 浏览器进行演示。使用散景可以快速、轻松地创建交互式绘图、仪表盘和数据应用程序。

用于 Python 数据可视化的散景

Bokeh 是一个 Python 交互式可视化库，它使用现代 web 浏览器进行演示。使用散景，我们可以轻松快速地创建交互式图表、仪表盘和数据应用程序 [ 1 ]

Bokeh 的最终目标是以 D3.js 的形式提供优雅的外观和恰当的可视化数据描述。Bokeh 对于那些希望快速轻松地创建交互式绘图、仪表板和数据应用程序的人非常有用。让我们看看 Python 数据可视化是如何使用散景完成的。

绘图类型

散景中的主要地块类型有:

服务器应用程序图

这些都连接到散景服务器，数据可以更新，从而更新绘图和用户界面。

独立图

这些地块不使用散景服务器。然而，它们仍然有许多交互式工具和功能，包括链接平移、刷动和悬停检查器。

安装散景

安装散景很简单，可以使用以下 pip 命令从 PyPI (python 包索引)安装到 Python 中:

pip install bokeh

或者，Anaconda 用户可以简单地运行命令:

conda install bokeh

这将从 Continuum Analytics Anaconda 存储库中安装最新发布的 Bokeh 版本，以及所有的依赖项。

一些 Bokeh 示例依赖于不包含在 Bokeh GitHub 存储库或发布的包中的样本数据，因为它们的大小。安装散景后，可以通过在 Python 解释器中执行以下命令来获取样本数据:

data visualization in python using bokeh 1 code quantinsti 散景入门

散景的架构是这样的，高层次的“模型对象”(代表像地块，范围，轴，字形等东西。)是用 Python 创建的，然后转换成 JSON 格式，由客户端库 BokehJS 使用。散景渲染视觉效果，并处理浏览器中散景图和部件的 UI 交互。

散景提供了两个主要界面，包括:

散景模型

一个低级界面，提供对如何组合和配置散景图和散景部件的完全控制。大多数模型都非常简单，通常由几个属性组成，没有方法。

散景绘图

一个中级界面，提供了一种方便的方法来创建以字形为中心的地块。字形是散景图的基本视觉构建块，例如线条、矩形、正方形、楔形、补丁等。

有多种方法可以生成散景文档的输出。它们包括:

  1. 为散景可视化生成简单的独立 HTML 文档
  2. output_notebook -在 Jupyter notebook 单元格中显示散景可视化效果

这些功能通常与显示或保存功能一起使用。

现在让我们绘制一些图表，展示散景图的简易性和威力。当我们带你浏览下面的图表示例时，我们将解释散景函数、方法和属性。

例 1:漂亮的行业指数表现

让我们从这个例子开始，绘制过去一年漂亮的行业指数表现。不同部门的名称和相应的年度报告载于清单中；“因子”和“x”。我们使用 bokeh.plotting 中的图形功能创建一个点对象，并应用“线段”和“圆”方法在点图中绘制线条和线条末端的圆。

由于回报既包括正回报也包括负回报，我们在循环 的 中使用了 if else 语句，并创建了一个列表(LineColor)，其中将“绿色”分配给正回报，将“红色”分配给负回报。

在“输出文件”功能中，我们指定了文件类型和文件名。“显示”功能以 html 格式显示图形。

Nifty Sectoral Indices Performance

1-Yr NIFTY Sectoral Indices Performance

例 2:俏皮传媒股表现

从上图可以看出，在过去的一年中，传媒板块涨幅最大(约 30%)。现在让我们来想象一下由各种各样的股票组成的漂亮的媒体板块的涨幅。股票回报数据是使用 pandas 的 read_csv 函数加载的。接下来，我们使用 bokeh.charts 中的散点函数来创建“散点”对象。我们在 x 轴上指定股票名称，在 y 轴上绘制回报率。“显示”功能以 html 格式显示散点图。您也可以使用“保存”功能保存该图。

Media Stocks PerformanceT3】

例 3:对比 TVTODAY 与 NIFTY 系列

你从散点图中观察到了什么？

我们可以看到，TVTODAY 的股票是漂亮的媒体行业中表现最好的股票之一，去年的回报率超过 40%。现在让我们画出 TVTODAY 价格系列，并与 NIFTY 指数进行比较。我们使用来自 pandas 的 read_csv 函数加载 TVTODAY 和漂亮的价格系列数据。使用 figure 函数，我们创建了“n”对象，并使用直线法绘制了 TVTODAY 价格序列。同样，我们绘制了漂亮的时间序列。

为了一个接一个地显示时间序列图，我们使用 bokeh.layouts 中的“column”函数，并将“n”和“p”对象传递给嵌套在“show”函数中的“column”函数(代码的最后一行)。这将产生一个接一个的时间序列图。

Nifty vs TVToday

NIFTY Vs TVTODAY Price SeriesT2】

例 4: TVTODAY 季度同比销售额&利润增长

比较上面的两个价格序列，我们可以观察到 TVTODAY 的股票在 11 月 15 日至 16 年 1 月期间出现大幅上涨，而 NIFTY 在同一时间框架内呈下跌趋势。TVTODAY 股票基本面能否解释大幅上涨？我们查看了 TVTODAY 股票的销售和利润增长数字，并绘制了一个涵盖过去四个季度的柱状图。

为了绘图，我们创建了一个包含过去四个季度的基本数据(销售额和净利润)的字典，并将其应用于 bokeh.charts 中的“Bar”函数。

TVToday Sales and Profit TVTODAY Quarterly YoY Sales & Profits Growth

从柱状图中，我们可以推断出 TVTODAY 在 2015 年 9 月、2015 年 12 月和 2016 年 3 月都取得了不错的业绩。此外，12 月初有对该公司有利的消息，允许 NRI 投资该公司。良好的季度业绩和利好消息为 11 月 15 日至 16 年 1 月期间的上涨趋势提供了一些解释。

这里有一篇关于在交互式代理 API 中实现 Python 代码的文章值得阅读。

总结

如上面的例子所示，散景非常用户友好，功能丰富，可以用来轻松地创建交互式图表。其网站上各种接口、功能、方法的大量文档使初学者学习散景很容易。

来自散景网站的有用链接

安装 -本节详细介绍了散景参考指南的安装过程-本文档提供了使用基本字形进行散景绘图的完整 API 参考 -详细介绍了使用散景绘图接口创建的散景图处理分类数据 -详细介绍了散景图中的分类数据添加注释-详细介绍了可以添加到可视化中的补充信息

下一步

学习可以使用 Python 对股票数据执行的基本操作，以分析和构建算法交易策略。在我们的文章“使用 Python 对股票数据的基本操作”中，我们介绍了一些可以使用 Python 对股票数据执行的基本操作，我们从读取 CSV 文件中的股票数据开始。

免责声明:股票市场的所有投资和交易都有风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。

zip 存档中的文件列表:

  • 数据文件作为输入
  • 所有示例的 Python 代码
  • 包含输出的 HTML 文件

Python 异常:在 Python 中引发和捕获异常

原文：https://blog.quantinsti.com/python-exception/

Python Exceptions - Raising And Catching Exceptions In Python

马里奥·比萨·培尼亚

在上一篇中，我们处理了 Python 错误，并对 Python 异常有了基本的了解:NameError 和 TypeError。在这篇文章中，我们将深入了解 Python 异常，以及如何引发和捕捉 Python 异常。

简单地说，在 Python 解析器中检测到 Python 错误，即当 Python 代码解释器发现一些语法不正确或不完整的语句时。

这些 python 错误很容易检测和修复，因为如果我们不纠正它们，我们将无法对代码做任何事情。这些 Python 错误被称为语法错误。

Python HandbookT3】

Python 异常

一方面，python 中存在错误，另一方面，Python 中存在异常(Python 异常)。解析器无法检测到这些类型的 python 错误，因为句子在语法上是正确和完整的，假设代码在逻辑上是有意义的，但是在运行时，它会发现一个意外情况，迫使执行停止。

这就是我们所说的异常，即。在这种情况下，Python 异常。幸运的是，我们可以正确处理这个 python 异常，防止代码突然结束执行。

了解 Python 异常

为了更好地理解 Python 异常，让我们看一个例子，并开始使用它。

例 1

1

在这个例子中，我们有一个非常简单的 Python 函数来将一个数除以另一个数(我们并不真的需要这个函数来除法，但它可以作为构建这个例子的结构)。

这段代码语法正确，完整，没有错误。但事实是，代码的正确执行将取决于我们传递给函数的值 x 和 y 。让我们测试一些值。

例 2

2

在本例中，我们用两个数字调用 simple_div(2，2)函数，该函数按预期工作，将数字相除。

例 3

3

在本例中，我们用两个数字调用 simple_div(0，2)函数，该函数按预期工作，将数字分开。

例 4

4

在这个例子中，我们用两个数字调用 simple_div(2，0)函数，这个函数没有像预期的那样工作，因为当我们用 0 除任何一个数字时，得到的是无穷大，而无穷大不是一个数字，因为无穷大是未知的，不可量化，因此，python 引发了一个异常，一个 Python 异常，在这个例子中称为 ZeroDivisionError ，执行突然结束，不允许我们继续(例如，我们可以等待结果来做其他操作)。

例 5

5

在本例中，我们用一个数字和一个字符调用 simple_div(2，' a ')函数，因此该函数不起作用，因为当我们用字符除任何数字时，python 引发了一个异常(Python 异常)，在本例中称为 TypeError ，执行突然结束，不允许我们继续。

例 6

6

在本例中，我们使用一个数字和一个名为 a 的变量调用 simple_div(2，a)函数，因此该函数不起作用，因为变量没有初始化，因此 python 引发了一个异常(Python 异常)，在本例中称为 NameError ，执行突然结束，不允许我们继续。

在任何一种情况下，如果我们等待函数的结果来继续计算，我们的代码会突然结束。

有几种方法可以控制这些意外情况，例如，控制代码可以防止调用没有编号的函数，并控制分母不为零。

另一种管理方法是控制 python 异常，如果出现异常，就在出现异常时捕获它们。我们称之为捕捉异常。

捕捉异常

我们现在要做的是控制代码执行中可能出现的异常情况(捕捉异常)，我们将尝试捕捉我们看到的第一个异常 ZeroDivisionError 。

注意到这个动词“尝试”是很有趣的，因为这正是我们要告诉 Python 去尝试做一些事情，如果它发现一个异常，就用它做一些事情。

在下面的函数中，我们试图执行一个除法，但是如果出现了 ZeroDivisionError Python 异常，我们希望捕获该异常并正确处理它，在这种情况下，在屏幕上打印一条消息并向用户提供一个清晰的输出。

7

我们还可以提供 type -1、9999 或-9999 的值，这将允许我们在代码的后面进行适当的处理。

8

现在让我们试着捕捉异常 TypeError，可以想象，它遵循相同的结构。

9

在异常 NameError 的情况下，变量 a 不存在，因此不允许从自己对函数的调用开始执行代码，也就是说，函数永远不会被执行，因为无法进行函数调用，因为我们试图传递给函数的变量不存在。

10

另一方面，我们可以遵循相同的结构来调用函数，也就是说，我们尝试调用函数，如果出现 python 异常 NameError，我们会正确处理它。

11

让我们把它们放在一起！

12

在第 12 块中，我们有一个接受两个输入参数的函数，并试图用它们进行除法运算。

我们也要记住，如果一些可预见的情况发生，我们可以妥善处理。

在块 13、14 和 15 中，我们简单地尝试调用函数，同时考虑到可能的 python 异常。

这些 python 异常可能是最典型的，但是我们可以使用内置在 python 语言中的许多其他 python 异常。

内置 Python 异常

这里有一个非常有用和重要的链接，它包含了所有的内置 Python 异常

结论

Python 为我们提供了使用所谓的 python 异常来实现干净执行的可能性，并允许我们对 python 代码执行中可能出现的某些异常进行处理。

在下一篇博客中，我们将会看到如何构建我们自己的 python 异常，并且我们将会详细了解像 Pandas 或 Numpy 这样的 python 库的 python 异常。

对于那些渴望了解更多关于 Python，它在算法和量化交易领域的使用和应用，或者只是想开始用 Python 进行交易的人，他们可以选择 Quantra 的 Python For Trading 课程。它从头开始涵盖了重要的概念，也有助于发展和提高专门针对交易的 Python 技能。

免责声明:股票市场的所有投资和交易都有风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。

丹尼尔为金融市场学习 Python 的故事

原文：https://blog.quantinsti.com/python-financial-markets-success-story-daniel-martin/

今天，时间是一种至关重要的资源，最大限度地利用时间至关重要。学习和培养你的技能是做到这一点的一种方式，让自己不断更新，不断学习，或获得认证。

疫情改变了我们的优先事项和关注点。随着封锁在全球范围内发生，渴望学习一些特定的东西是一条追求的道路。

Daniel M .是一名自由职业 IT 顾问，来自美丽的国家罗马尼亚。我们采访了他，了解他在 IT 领域长达 15 年的职业生涯后，从“技术人员”到为金融市场学习 Python 的历程。

丹尼尔用他的话分享了他的旅程。

我是来自罗尼亚的丹尼尔 M. 。在过去的 15 年里，我一直在 IT 行业担任项目经理。截至目前，我是一名自由职业的 IT 顾问。

我第一次接触信息技术始于多年前，当时我接触了编程的概念，以及机器如何使用逻辑、数学和序列来进行繁重的计算，比古代的纸质计算要快得多。这段经历基本上引导了我个人努力学习更多的知识，并追求计算机科学方面的高等教育。

回想起来，很难在教育和工作之间划清界限，因为我的职业经历让我身兼数职，从“技术人员”开始，一直到商业咨询和项目管理。

我一直对金融市场感兴趣，但从未真正有机会深入探索。这个疫情给了我时间去探索其他领域。

目前，由于我有一些时间，并且我非常了解编程和技术方面的事情，我决定最终开始学习算法交易。

我想学习更多关于 Python 的知识，因为现在它在金融领域被广泛使用。我只是对它很熟悉，但在我的工作中从来没有真正有机会使用它。我在网上寻找 Python 课程，在遇到 Quantra 之前，我也在其他平台上学习课程。

事实是，在今天这个时代，网上有很多可用的东西，但随着这些东西的丰富，很难过滤掉所有不相关的东西来获得真正有价值的东西。

Quantra 正在推动价值系数更高，同时不浪费任何人的时间，为您提供有顺序的课程和明确定义的培训交付，以及非常接近现实的实际例子。

在课程的功能方面，课程被设计成让你遵循一种非常自然的学习方式。对我个人来说，培训是一次美好的经历。课程大纲是以合乎逻辑的方式设计的。

利用从免费 Python 课程中学到的知识，我建立了一个包含股票“开盘价”、“高价位”、“低价位”、“收盘价”、“成交量”数据的数据库。我计划探索这个数据库，建立一个策略，进行回溯测试，也许会在市场上推出。

我的下一步将是更深入地挖掘事物的技术分析方面，并开始探索金融的机器学习和人工智能领域。

我是一个很挑剔的人，能打动我的东西真的很少。Quantra 就是其中之一。我会再回来找你，我这边已经测试过你们的质量了。

丹尼尔，谢谢你的美言。我们很高兴看到您在 Quantra 获得了很好的学习体验。期待您也加入我们的其他课程！

像丹尼尔一样，如果你也想在算法交易领域起步或出类拔萃， Quantra 的自定进度和小型课程提供了一种快速的方法，让有动力的学习者获得和完善所需的技能。

免责声明:本文提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害负责。所有信息均按原样提供。

Python 函数教程:定义、类型、命名空间和范围

原文：https://blog.quantinsti.com/python-function-tutorial/

杰伊·帕尔马

今天，我们将探索几乎所有编程语言中都有的一个非常方便的特性:函数。Python 及其生态系统中有许多奇妙的内置函数。然而，作为 Python 程序员，我们经常需要编写自定义函数来解决我们特有的问题。这是函数的定义。

函数是一段代码(执行特定的任务),只有在被调用时才会运行。

从定义中可以推断出，编写这样的代码块，即函数，提供了如下好处

  • 可重用性:在 python 函数中编写的代码可以在需要的时候被调用。因此，可以重用相同的代码，从而减少代码的总行数。
  • 模块化方法:编写 python 函数隐含地遵循模块化方法。我们可以将我们试图解决的整个问题分解成更小的块，每个块依次通过一个函数来实现。

我们将在本 python 函数教程中讨论以下几点:

在编写程序时，Python 函数可以被认为是构建模块，随着我们的程序不断变得更大、更复杂，函数有助于使它更有组织、更易于管理。它们允许我们给代码块起一个名字，允许我们在程序的任何地方使用给定的名字运行代码块任意次。这被称为调用一个 python 函数。例如，如果我们想计算一个列表的长度，我们调用一个内置的len函数。使用任何 python 函数意味着我们调用它来执行它被设计的任务。

我们需要在调用len函数时向它提供一个输入。我们提供给 python 函数的输入被称为参数。它可以是数据结构、字符串、值或引用它们的变量。根据功能的不同，函数可以有单个或多个参数。

python 函数有三种类型:

  • 内置的 python 函数，比如在标准输出设备上打印的print，检查对象数据类型的type等。这些是 Python 提供的用于完成常见任务的函数。
  • 用户定义的 python 函数:顾名思义，这些是帮助/解决/完成特定任务的自定义函数。
  • 匿名 python 函数，也称为 lambda 函数，是定制的，没有任何名称标识符。

内置 python 函数

内置函数是 Python 提供的函数。我们现在将讨论其中的几个:

  • type(object)用于检查对象的数据类型。

  • float([value])返回由数字或字符串值构造的浮点数。

  • int([value])返回一个由浮点或字符串值构造的整数对象，如果没有给定参数，则返回 0。

  • round(number[, ndigits])用于将浮点数的四舍五入到 ndigits 指定的位数。

  • abs(value)返回作为参数提供的值的绝对值。

  • format(value[, format_spec])将一个值转换成一个‘格式化’的表示，由 format_spec 控制。

  • str([object])返回一个字符串版本的对象。如果未提供对象，则返回空字符串。

  • bool([value])返回一个布尔值，即True或False之一。值使用标准真值测试程序[1]进行转换。如果值为假或省略，则返回False；否则，它返回True。

  • dir([object])当未提供参数时，返回当前局部范围内的名称列表。如果使用参数，它会尝试返回该对象的有效属性列表。

  • len(object)返回一个对象的长度(项目数)。参数可以是序列(如字符串、字节、元组、列表或范围)或集合(如字典、集合或冻结集)。

值得注意的是，几乎所有内置 python 函数都接受一个或多个参数，对其执行特定操作并返回输出。随着我们 python 学习之旅的进展，我们将继续学习更多的内置 Python 函数。关于各种内置函数的更多信息可以从 Python 官方文档中获得

用户定义的 python 函数

尽管 python 提供了大量的内置 Python 函数，但它不足以解决我们在开发程序和应用程序时会遇到的问题。作为 Python 程序员，我们可能需要将编程挑战分解成更小的块，并以自定义或用户定义的函数的形式实现它们。编写函数的概念可能是任何编程语言的基本特征。

函数是用关键字def定义的，后面跟着一个标识符名和括号，最后是结束一行的冒号。构成函数的主体的语句块遵循函数定义。这里有一个简单的例子。

def greet():
 """Block of statement.
 or Body of function."""
 print(' Hello from inside the function!')

上面定义的greet函数可以用它的名字调用，如下所示。

# Calling the function
greet()

输出将会是

Hello from inside the function.

只有一个参数的 Python 函数

我们可以任意多次调用一个函数，Python 会执行函数体中的语句。我们上面提到的 python 函数，既不接受任何输入，也不返回任何输出。它只是打印写在里面的语句。如果函数必须接受任何输入，那么在函数定义期间，它会作为一个参数放在括号中。参数是我们提供给函数的值，这样函数就可以利用这些值做一些事情。

请注意这里使用的术语:

  • 参数:它们在函数定义中的括号内指定，用逗号分隔。
  • Arguments :当我们调用一个 python 函数时，参数的取值将以逗号分隔的格式作为参数给出。

上述简单 python 函数的修改版本解释了这两个术语:

# Here 'person_name' is a parameter.
def greet(person_name):
 """Prints greetings along with the value received via the parameter."""
 print('Hello ' + person_name + '!')

上面的函数定义将person_name定义为函数greet的一个参数，可以如下调用:

# Calling the function
greet('Amigo')

上面对函数greet的调用将字符串Amigo作为参数，输出如下:

Hello Amigo!

带有多个参数和一个return语句的 Python 函数

上面定义的两个版本的greet python 函数实际上在它们执行的功能方面都很简单。函数能够执行的另一个功能是使用关键字return向调用语句返回值。考虑一个函数，它接受几个参数，对其执行一些数学计算并返回输出。例如:

# Function with two parameters 'a' and 'b'
def add(a, b):
 """Computes the addition and returns the result.
 It does not implement the print statement."""
 result = a + b # Computes addition
 return result # Returns the result variable

这个用户定义函数add接受两个参数a和b，将它们相加，并将其输出赋给一个变量result，最终将该变量返回给调用语句，如下所示:

# Calling the add function
x = 5
y = 6
print(f'The addition of {x} and {y} is {add(x, y)}.')

我们用两个参数x和y调用函数add(因为函数定义有两个参数)，分别用5和6初始化，函数返回的加法通过print语句打印出来，如下所示:

The addition of 5 and 6 is 11.

类似地，python 函数也可以基于实现返回多个值。下面的函数演示了同样的情况。

# Function definition
def upper_lower(x):
 """Returns the upper and lower version of the string.
 The value must be a string, else it will result in an error.
 This function does not implement any error handling mechanism."""
 upper = x.upper() # Convert x to upper string
 lower = x.lower() # Convert x to lower string
 return upper, lower # Return both variables upper and lower

上面的upper_lower函数接受一个参数x(一个字符串)并将其转换成它们的大写和小写版本。让我们调用它，看看输出。

注意:函数 upper_lower 隐式地假设有一个字符串作为参数。调用时提供整数或浮点值作为参数将导致错误。

# Calling the function
upper, lower = upper_lower('Python')
# Printing output
print(upper)
PYTHON
print(lower)
python

这里，对upper_lower函数的调用被分配给了两个变量upper和lower，因为该函数返回两个值，这两个值将分别被解包到每个变量中，同样的情况可以在上面显示的输出中得到验证。

带默认参数的 Python 函数

比方说，我们正在编写一个接受多个参数的函数。通常，这些参数中的一些有共同的值。在这种情况下，我们希望能够在不明确指定每个参数的情况下调用函数。换句话说，我们希望一些参数有默认值，当它们没有在函数调用中被指定时，这些默认值将被使用。

要使用默认参数值定义 python 函数，我们需要在定义函数时为感兴趣的参数赋值。

def power(number, pow=2):
 """Returns the value of number to the power of pow."""
 return number**pow

请注意，上面的 python 函数计算第一个参数的第二个参数的幂。后者的默认值为 2。所以现在当我们只使用一个参数调用 python 函数power时，它将被赋值给number参数，返回值将通过平方number得到。

# Calling the power function only with required argument
print(power(2))
# Output
4

换句话说，第二个参数pow的参数值是可选的。如果我们想计算不同幂的数字，我们显然可以为它提供一个值，python 函数将返回相应的值。

# Calling the power function with both arguments
print(power(2, 5)
# Output
32

python 函数中可以有任意数量的默认值参数。但是请注意，它们必须跟在定义中的非默认值参数后面。否则，Python 将抛出如下所示的错误:

# Calling the power function that will throw an error
def power(pow=2, number):
 """Returns the raised number to the power of pow."""
 return number**pow
 File "<ipython-input-57-9d342db32aba>", line 1
 def power(pow=2, number):
 ^
SyntaxError: non-default argument follows default argument

具有可变长度参数的 Python 函数

让我们考虑一个场景，作为开发人员，我们不确定用户在调用 python 函数时想要传递多少个参数。例如，一个函数接受浮点数或整数(不管它们有多少)作为参数，并返回它们的和。我们可以实现如下所示的场景:

def sum_all(*args):
 """Sum all values in the *args."""
 # Initialize result to 0
 result = 0
 # Sum all values
 for i in args:
 result += i
 # Return the result
 return result

在 python 函数定义中，可变参数被写成*，后跟参数名。参数args前面的*表示该参数长度可变。Python 然后将它解包到一个同名的元组中，这个元组可以在函数中使用。在上面的例子中，我们将变量result初始化为 0，它将保存所有参数的总和。然后我们循环遍历args来计算总和，并在每次迭代中更新result。最后，我们将总和返回给调用语句。可以使用任意数量的参数调用sum_all python 函数，它会将所有参数相加，如下所示:

# Calling the sum_all function with arbitrary number of arguments.
print(sum_all(1, 2, 3, 4, 5))
# Output
15
# Calling with different numbers of arguments.
print(sum_all(15, 20, 6))
# Output
41

这里，*args被用作参数名(参数的简写)，但是我们可以使用任何有效的标识符作为参数名。它只需要在前面加一个*就可以使它的长度灵活。在同样的行中，Python 提供了另一种风格的灵活参数，前面有两个星号标记。使用时，它们被解释器解压到字典(同名)中，并且可以在函数中使用。例如:

def info(**kwargs):
 """Print out key-value pairs in **kwargs."""
 # Run for loop to prints dictionary items
 for key, value in kwargs.items():
 print(key + ': ' + value)

这里，参数**kwargs被称为关键字参数，它们将被转换成同名的字典。然后我们对它进行循环，并打印所有的键和值。同样，使用不同于kwargs的标识符作为参数名是完全有效的。可以如下调用info python 函数:

# Calling the function
print(info(ticker='AAPL', price='146.83', name='Apple Inc.', country='US'))
# Output
ticker: AAPL
price: 146.83
name: Apple Inc.
country: US

这就是所有关于默认和灵活的参数。我们现在试图转向 python 函数的文档部分。

文档字符串

Python 有一个很棒的特性，叫做文档字符串，通常用它的简称文档字符串来指代。这是一个重要但不是必需的工具，我们每次写程序时都应该使用，因为它有助于更好地记录程序，并使程序更容易理解。

文档字符串写在定义头后面的三个单引号/双引号内。它们写在 python 函数的第一个逻辑行。文档字符串不仅限于函数；它们也适用于模块和类。docstring 遵循的约定是多行字符串，其中第一行以大写字母开始，以点结束。第二行是空白，从第三行开始是任何详细的解释。强烈建议所有文档字符串都遵循这一约定。让我们通过一个例子来看看这一点:

def power(x, y):
 """Equivalent to x**y or built-in pow() with two arguments.
 x and y should be numerical values else an appropriate error will be thrown for incompatible types.
 Parameters:
 x (int or float): Base value for the power operation.
 y (int or float): Power to which base value should be raised.
 Returns:
 int or float: It returns x raised to the power of y.
 """
 try:
 return x ** y
 except Exception as e:
 print(e)

上面定义的 python 函数power将参数x的提升值返回给y。我们感兴趣的是写在'''中的 docstring，它记录了函数。我们可以使用任何函数的__doc__属性(注意该函数的双下划线)来访问该函数的 docstring。可以使用以下代码访问power函数的 docstring:

print(power.__doc__)

输出如下所示:

Equivalent to x**y or built-in pow() with two arguments.
x and y should be numerical values else an appropriate error will be thrown for incompatible types.
Parameters:
x (int or float): Base value for the power operation.
y (int or float): Power to which base value should be raised.
Returns:
int or float: It returns x raised to the power of y.

我们已经在前面的章节中看到了 docstrings 的间接用法。当我们在 python 中使用 Python 函数help时，它会显示 docstring。它所做的是获取该函数的__doc__属性，并以简洁的方式显示出来。如果我们使用print(help(power))请求关于用户定义的power的帮助，Python 将返回与我们使用print(power.__doc__)得到的相同的输出，如上所示。

嵌套 python 函数和非局部变量

嵌套 python 函数是在另一个函数内部定义的函数。嵌套函数的语法与任何其他 python 函数的语法相同。尽管嵌套函数的应用在本质上是复杂的，有时也是有限的，即使在量子领域也是如此，但还是值得一提，因为我们可能会在野外遇到这种情况。下面是一个演示嵌套 python 函数的示例。

# Defining nested function
def outer():
 """ This is an enclosing function """
 def inner():
 """ This is a nested function """
 print('Got printed from the nested function.')
 print('Got printed from the outer function.')
 inner()

我们定义了 python 函数outer，其中嵌套了另一个 python 函数inner。outer函数被称为包围函数的，而inner被称为嵌套函数。它们有时也被称为内部函数。在调用outer函数时，Python 将依次调用嵌套在其中的inner函数并执行它。同样的输出如下所示:

# Calling the 'outer' function
outer()
# Output
Got printed from the outer function.
Got printed from the nested function.

我们在这里得到的输出是直观的。首先，outer函数中的print语句被执行，然后是inner函数中的print语句。此外，嵌套函数可以访问封闭函数的变量。即外部函数中定义的变量可以被内部函数访问。但是，内部或嵌套 python 函数不能修改外部或封闭 python 函数中定义的变量。

def outer(n):
 number = n
 def inner():
 print('Number =', number)
 inner()

对outer函数的调用将打印以下内容

outer(5)
# Output
Number = 5

虽然变量number没有在inner函数中定义，但是它可以访问并打印number。这是可能的，因为 Python 提供了范围机制。我们将在下一节详细讨论这一点。现在考虑一下，如果我们希望嵌套的 python 函数修改在封闭 python 函数中声明的变量，会怎么样呢？Python 的默认行为不允许这样做。如果我们试图修改它，我们将面临一个错误。为了处理这种情况，关键字nonlocal就来了。

在嵌套 python 函数中，我们使用关键字nonlocal来创建和更改封闭 python 函数中定义的变量。在下面的例子中，我们改变了变量number的值。

def outer(n):
 number = n
 def inner():
 nonlocal number
 number = number ** 2
 print('Square of number =', number)
 print('Number =', number)
 inner()
 print('Number =', number)

对outer python 函数的调用现在将打印作为参数传递给它的数字、它的平方和新更新的数字(只是平方的数字)。

outer(3)
# Output
Number = 3
Square of number = 9
Number = 9

请记住，为变量赋值只会在特定的 python 函数(或范围)内创建或更改变量，除非它们是使用非局部语句声明的。

变量的命名空间和作用域

如果我们阅读了Python 的禅宗(在 Python 控制台中尝试import this)，最后一行声明名称空间是一个非常棒的想法——让我们做更多这样的事情吧！让我们试着理解这些神秘的名称空间是什么。然而，在此之前，花点时间了解一下 Python 环境中的名称是值得的。

Python 世界中的名称

一个名(也称为标识符)就是给一个对象起的名字。从 Python 基础知识中，我们知道 Python 中的一切都是对象。名称是访问底层对象的一种方式。让我们创建一个名为price的值为 144 的新变量，并检查 python 函数id可访问的内存位置标识符。

# Creating new variable
price = 144
# Case 1: Print memory id of the variable price
print(id(price))
# Case 1: Output
1948155424
# Case 2: Print memory id of the absolute value 144
print(id(144))
# Case 2: Output
1948155424

有趣的是，我们看到两种情况下的内存位置(变量及其赋值)是相同的。换句话说，两者都引用同一个整数对象。如果您在工作站上执行上述代码，内存位置几乎肯定会不同，但对于变量和值来说是相同的。让我们给它增添更多的乐趣。考虑以下代码:

# Assign price to old_price
old_price = price
# Assign new value to price
price = price + 1
# Print price
print(price)
# Output
145
# Print memory location of price and 145
print('Memory location of price:', id(price))
print('Memory location of 145:', id(145))
# Output
Memory location of price: 1948155456
Memory location of 145: 1948155456
# Print memory location of old_price and 144
print('Memory location of old_price:', id(old_price))
print('Memory location of 144:', id(144))
# Output
Memory location of old_price: 1948155424
Memory location of 144: 1948155424

我们将变量price的值增加了 1 个单位，看到它的内存位置发生了变化。您可能已经猜到，整数对象145的内存位置也将与price的内存位置相同。但是，如果我们检查变量old_price的内存位置，它将指向整数对象144的内存位置。这很有效，因为 Python 不需要创建重复的对象。这也使得 Python 功能强大，因为名字可以指代任何对象，甚至是函数。注意，python 函数也是 Python 中的对象。既然我们知道了 Python 中名称的本质，我们就可以仔细研究名称空间了。

命名空间

名字冲突在现实生活中时有发生。比如我们经常看到一个教室里有多个同名 X 的学生。如果有人必须呼叫学生 X，那么在确定哪个学生 X 实际上被呼叫时会有冲突的情况。在打电话时，可以使用学生的姓和名来确保打给正确的学生 x。

同样，这种冲突也会出现在编程中。当程序很小而没有任何外部依赖时，拥有唯一的名字是容易和可管理的。当程序变得更大和外部模块被合并时，事情开始变得复杂。当程序跨越数百行时，为程序中的所有对象指定唯一的名称变得困难和令人厌烦。

命名空间可以被认为是一个命名系统，以避免名称之间的歧义，并确保程序中的所有名称都是唯一的，并且可以在没有任何冲突的情况下使用。在 Python 中，大多数名称空间都是作为字典来实现的。有一个名称到对象的映射，名称作为键，对象作为值。多个名称空间可以使用相同的名称，并将其映射到不同的对象。名称空间是在不同的时刻创建的，具有不同的生存期。命名空间的示例有:

  • 内置名称集:它包括内置函数和内置异常名称。
  • 模块中的全局名称:它包括从程序中导入的各种模块的名称。
  • 函数中的局部名字:它包括函数内部的名字。它是在调用 python 函数时创建的，一直持续到函数返回。

关于名称空间，需要知道的重要一点是，不同名称空间中的名称之间绝对没有关系；也就是说，两个不同的模块可以包含一个函数sum而没有任何冲突或混淆。但是，在使用它们时，必须以模块名为前缀。

领域

到目前为止，我们一直在程序的任何地方使用对象。然而，需要注意的一件重要事情是，并不是所有的对象在程序中的任何地方都是可访问的。这就是范围概念的由来。范围是 Python 程序的一个区域，在这里可以直接访问名称空间。即当对名称(列表、元组、变量等)的引用。)之后，Python 会尝试在名称空间中查找这个名称。不同类型的范围是:

局部范围:在局部范围内定义的名字意味着它们是在 python 函数内定义的。它们只能在函数中访问。在函数内部定义的名字不能在函数外部访问。一旦函数的执行结束，局部作用域内的名字就不复存在了。下图说明了这一点:

# Defining a function
def print_number():
 # This is local scope
 n = 10
 # Printing number
 print('Within function: Number is', n)
print_number()
# This statement will cause error when executed
print('Outside function: Number is', n)
# Output
Within function: Number is 10
Traceback (most recent call last):
 File "<ipython-input-2-f44bdaae6d53>", line 8, in <module>
 print('Outside function: Number is', n)
NameError: name 'n' is not defined

封闭作用域:封闭作用域中的名字是指在封闭函数中定义的名字。当引用的名称在本地范围内不可用时，将在封闭范围内进行搜索。这就是所谓的范围解析。下面的例子有助于我们更好地理解这一点:

# This is enclosing / outer function
def outer():
 number = 10
 # This is nested / inner function
 def inner():
 print('Number is', number)
 inner()
outer()
# Output
Number is 10

我们试图在没有定义变量inner的函数中打印变量number。因此，python 试图在作为封闭 Python 函数的outer函数中找到变量。如果在封闭范围内也找不到该变量怎么办？Python 将试图在我们接下来讨论的全局范围内找到它。

全局作用域:全局作用域中的名字意味着它们是在程序的主脚本中定义的。几乎在程序的任何地方都可以访问它们。考虑下面的例子，我们在函数定义之前定义了一个变量n(即在全局范围内),并在 python 函数中定义了另一个同名的变量n。

# Global variable
n = 3
def relu(val):
 # Local variable
 n = max(0, val)
 return n
print('First statement: ', relu(-3))
print('Second statement:', n)
# Output
First statement: 0
Second statement: 3

这里，第一个 print 语句调用值为-3的relu函数，该函数将最大值赋值为 0，并将最大值赋给变量n，该变量又被返回，从而打印出 0。接下来，我们尝试打印n和 Python 打印3。这是因为 Python 现在引用了函数外部(全局范围内)定义的变量n。因此，我们得到了两个不同的值n,因为它们位于不同的范围内。这给我们带来了一个显而易见的问题，如果变量不是在局部范围内定义的，而是在全局范围内可用，并且我们试图访问那个全局变量，那该怎么办？答案很直观，我们将能够在 python 函数中访问它。然而，它是一个只读变量，因此我们不能修改它。试图修改全局变量会导致如下所示的错误:

# Global variable
number = 5
# Function that updates the global variable
def update_number():
 number = number + 2
 print('Within function: Number is', number)
# Calling the function
update_number()
print('Outside function: Number is', number)
# Output
Traceback (most recent call last):
 File "<ipython-input-8-267134da25e4>", line 8, in <module>
 update_number()
 File "<ipython-input-8-267134da25e4>", line 4, in update_number
 number = number + 2
UnboundLocalError: local variable 'number' referenced before assignment

为了处理这种需要修改全局名称的情况，我们在 python 函数中定义了全局名称，后跟关键字global。global关键字允许我们在局部范围内访问全局名称。让我们运行上面的代码，但是使用global关键字。

# Global variable
number = 5
# Function that updates the global variable
def update_number():
 global number
 number = number + 2
 print('Within function: Number is', number)
# Calling the function
update_number()
print('Outside function: Number is', number)
# Output
Within function: Number is 7
Outside function: Number is 7

关键字global允许我们从局部范围修改全局变量，没有任何问题。这与关键字non-local非常相似，它允许我们修改封闭范围中定义的变量。

内置作用域:该作用域由 Python 内置模块中预定义的名称组成，如sum、print、type等。尽管我们既没有在程序中的任何地方定义这些 python 函数，也没有从任何外部模块中导入它们，但是它们总是可以使用的。

总而言之，在执行 Python 代码时，会按以下顺序在各种范围内搜索名称:

  1. 当地的
  2. 封闭
  3. 全球的
  4. 内置的

如果在任何范围内都找不到它们，Python 将抛出一个错误。

Lambda python 函数

我们已经使用def关键字、函数头、文档字符串和函数体编写了上面的函数。用 Python 编写动态函数有一种更快的方法，它们被称为 lambda 函数。它们有时也被称为匿名 python 函数。我们用关键字lambda来写这样的函数。lambda 函数的语法如下:

lambda arguments: expression

首先，语法显示没有 python 函数名。其次，实参指参数，最后，表达式描绘了 python 函数体。让我们创建一个 python 函数square，它对提供给它的参数求平方并返回结果。我们使用关键字def创建这个 python 函数。

# Function defnition
def square(arg):
 """Computes the square of an argument and returns the result.
 It does not implement the print statement."""
 result = arg * arg
 return result
# Calling the function and printing its output
print(square(3))
# Output
9

上面定义的 python 函数square可以使用关键字lambda重写为一行，如下所示:

# Creating a lambda function and assigning it to square
square = lambda arg: arg * arg
# Calling the lambda function using the name 'square'
print(square(3))
# Outpuut
9

在上面的 lambda python 函数中，它接受一个由 arg 表示的参数，并返回它的平方。Lambda python 函数在定义期间，在关键字lambda之后可以有任意数量的参数。为了理解多个参数是如何工作的，我们将把我们的讨论限制到两个参数。我们创建另一个 lambda 函数，将第一个参数提升到第二个参数的幂。

# Creating a lambda function to mimic 'raise to power' operation
power = lambda a, b: a ** b
# Calling the lambda function using the name 'power'
print(power(2, 3))
# Output
8

Lambda python 函数与内置的map和filter函数一起被广泛使用。

map()功能

map函数有两个参数:一个函数和一个序列，比如一个列表。这个 python 函数创建了一个迭代器，它将函数应用于序列的每个元素。我们可以将 lambda python 函数传递给这个map函数，甚至不用命名它。在这种情况下，我们将 lambda 函数称为匿名函数。在下面的例子中，我们创建了一个由数字组成的列表nums，并将其传递给一个map函数和 lambda 函数，后者将对列表中的每个元素求平方。

# Creating a list of all numbers
nums = [1, 2, 3, 4, 5]
# Defining a lambda function to square each number and passing it as an argument to map function
squares = map(lambda num: num ** 2, nums)

上例中的 lambda python 函数将对列表nums中的每个元素求平方，map 函数将每个输出映射到原始列表中的相应元素。然后，我们将结果存储到一个名为squares的变量中。如果我们打印出square变量，Python 会告诉我们这是一个地图对象。

# Printing squares
print(squares)
# Output
<map object at 0x00000000074EAD68>

要查看该对象包含的内容，我们需要使用如下所示的list python 函数将其转换为 list:

# Casting map object squares to a list and printing it
print(list(squares))
# Output
[1, 4, 9, 16, 25]

filter()功能

filter函数有两个参数:一个函数或None和一个序列。这个函数提供了一种从列表中过滤掉不满足特定标准的元素的方法。在嵌入 lambda 函数之前，让我们先了解一下它是如何工作的。

# Creating a list of booleans
booleans = [False, True, True, False, True]
# Filtering 'booleans', casting it to a list, and finally printing it
print(list(filter(None, booleans)))
# Output
[True, True, True]

在上面的例子中，我们首先创建一个随机布尔值列表。接下来，我们将它和指定返回为真的项目的None一起传递给filter函数。最后，我们将filter函数的输出转换为一个列表，因为它输出一个过滤器对象。在更高级的场景中，我们可以在filter函数中嵌入一个 lambda 函数。假设我们有一个场景，我们需要从一组给定的字符串中过滤出所有长度大于 3 的字符串。我们可以一起使用 filter 和 lambda 函数来实现这一点。下图说明了这一点:

# Creating a pool of random strings
strings = ['one', 'two', 'three', 'four', 'five', 'six']
# Filtering strings using a lambda and filter functions
filtered_strings = filter(lambda string: len(string) > 3, strings)
# Casting 'filtered_strings' to a list and printing it
print(list(filtered_strings))
# Output
['three', 'four', 'five']

在上面的例子中，在filter函数中使用了 lambda python 函数，它检查strings列表中每个字符串的长度。然后filter函数将过滤出与 lambda 函数定义的标准相匹配的字符串。

除了上面讨论的map和filter python 函数，现在我们将学习另一个方便的函数zip，它可以用于同时遍历多个序列。

zip()功能

作为普通的电脑用户，我们经常会遇到带有的文件。zip 扩展名又名 zip 文件。基本上，这些文件是压缩了其他文件的文件。换句话说，zip 文件就像一个容纳其他文件的容器。

在 Python 的世界里，zip python 函数或多或少地充当了可迭代对象的容器，而不是真正的文件。zip的语法如下所示:

zip(*iterables)

它将一个 iterable 作为输入，并返回一个迭代器，该迭代器从每个 iterable 中聚合元素。输出包含一个元组的迭代器。迭代器中的第个元素是由每个输入的第个元素组成的元组。如果输入中的可迭代对象大小不相等，当最短的输入可迭代对象用尽时，输出迭代器停止。如果没有输入，它将返回一个空迭代器。让我们借助一个例子来理解zip的工作原理。

# Defining iterables for the input
tickers = ['AAPL', 'MSFT', 'GOOG']
companies = ['Apple Inc', 'Microsoft Corporation', 'Alphabet Inc']
# Zipping the above defined iterables using the 'zip'
zipped = zip(tickers, companies)

我们定义了两个列表tickers和companies，它们被用作zip的输入。zipped对象是zip类型的迭代器，因此我们可以使用循环技术对其进行迭代以打印其内容:

# Iterating over a zipped object
for ticker, company in zipped:
 print('Ticker name of {} is {}.'.format(ticker, company))
# Output
Ticker name of AAPL is Apple Inc.
Ticker name of MSFT is Microsoft Corporation.
Ticker name of GOOG is Alphabet Inc.

或者很容易将其转换为顺序数据结构，如列表或元组。

# Casting the zip object to a list and printing it
print(list(zipped))
# Output
[('AAPL', 'Apple Inc.'),
 ('MSFT', 'Microsoft Corporation'),
 ('GOOG', 'Alphabet Inc.')]

正如我们所料，压缩对象包含一个元组序列，其中的元素来自相应的输入。一个zip对象和*一起像以前一样解压元素。例如:

# Unzipping the zipped object
new_tickers, new_companies = zip(*zipped)
# Printing new unzipped sequences
print(new_tickers)
('AAPL', 'MSFT', 'GOOG')
print(new_companies)
('Apple Inc.', 'Microsoft Corporation', 'Alphabet Inc.')

我们将 zip 对象zipped解压成两个序列new_tickers和new_companies。通过打印这些序列，我们可以看到操作成功了，元素成功地解压缩到各自的元组中。

结论

因此，我们已经看到了不同类型的 python 函数以及如何调用它们。我们还看到了 python 函数如何让我们的编程生活变得更加轻松。我们还看到了 python 函数中的名称空间及其范围。

如果你想学习算法交易的各个方面，那就去看看算法交易的高管课程( EPAT )。课程涵盖统计学&计量经济学、金融计算&技术和算法&定量交易等培训模块。EPAT 教你在算法交易中建立一个有前途的职业所需的技能。立即报名！

免责声明:本文中提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害承担任何责任。所有信息均按原样提供。

Python Matplotlib 教程:绘制数据和定制

原文：https://blog.quantinsti.com/python-matplotlib-tutorial/

杰伊·帕尔马

Matplotlib 是一个流行的 Python 库，可用于非常容易地创建数据可视化。它可能是 2D 图形中使用最多的 Python 包，对 3D 图形的支持有限。它既提供了一种非常快速的方式来可视化来自 Python 的数据，又提供了多种格式的出版物质量的数字。此外，它从一开始就被设计用于两个目的:

  1. 允许图形和情节的交互、跨平台控制
  2. 无需任何图形用户界面，轻松生成静态矢量图形文件。

与 Python 本身非常相似，Matplotlib 让开发人员可以完全控制他们的绘图外观。它试图把简单的事情变得简单，把困难的事情变得可能。我们可以生成图表、直方图、功率谱、条形图、误差图、散点图等。只需要几行代码。对于简单的绘图，matplotlib包中的pyplot模块为底层面向对象绘图库提供了一个类似 MATLAB 的接口。它隐式地自动创建图形和轴，以实现所需的绘图。
T3T5T7】

在 Python Matplotlib 教程中，我们将讨论以下主题:

如何导入 Python Matplotlib

为了开始使用 Python Matplotlib，我们首先导入包。使用别名作为plt来导入matplotlib.pyplot是一种常见的做法。pyplot是 Matplotlib 中的子包，提供了通用的图表功能。此外，如果我们在 Jupyter 笔记本中工作，行%matplotlib inline变得很重要，因为它确保图形嵌入到笔记本中。下面的示例演示了这一点:

import matplotlib.pyplot as plt

%matplotlib inline

不属于 Python 标准库，因此，像任何其他第三方库一样，它需要安装后才能使用。可以使用命令pip install matplotlib进行安装。

你可以通过下面的博客了解如何安装和导入 Python 包。至此，您已经了解了如何导入 matplotlib。在我们开始绘制图表之前，让我们首先理解 Python matplotlib 教程下一节中的关键术语。

Matplotlib 中的基本术语和概念

Python Matplotlib 允许创建各种各样的绘图和图形。Matplotlib 是一个大型项目，乍一看可能会令人望而生畏。然而，我们将开始学习组件，它应该感觉更小，更容易接近。

不同的来源用“情节”来表示不同的东西。因此，让我们从定义跨领域使用的特定术语开始。

  • Figure是层次结构中的顶级容器。它是绘制所有内容的整体窗口。我们可以有多个独立的图形，每个图形可以有多个Axes。可以使用pyplot模块的figure方法创建。

  • Axes是绘图发生的地方。轴实际上是我们绘制数据的区域。每个Axes都有一个X-Axis和一个Y-Axis。

下面提到的例子说明了上述术语的用法:

fig = plt.figure()

在运行上面的例子时，实际上什么也没有发生。它只创建了一个大小为 432 x 288 的 0 轴图形。另外，Python Matplotlib 不会显示任何东西，直到被告知这样做。Python 将等待对show方法的调用来显示绘图。这是因为我们可能想在显示之前向绘图添加一些额外的特性，比如标题和标签定制。因此，我们需要调用plt.show()方法来显示下图:

plt.show()

由于没有什么可绘制的，所以不会有输出。当我们进入主题时，我们可以通过figsize参数控制图形的大小，它需要一个以英寸为单位的(width，height)元组。

fig = plt.figure(figsize=(8, 4))

plt.show()

轴线

所有绘图都是相对于一个Axes完成的。一个轴是由Axis物体和许多其他东西组成的。一个轴对象必须属于一个Figure。我们在 Python mathplotlib 中发布的大多数命令都与这个轴对象有关。通常，我们会设置一个Figure，然后在其上添加Axes。我们可以使用fig.add_axes，但在大多数情况下，我们发现添加一个支线剧情完全符合我们的需要。子图是网格系统中的一个轴。

  • 方法将一个Axes添加到图形中，作为子情节排列的一部分。
""" Example 1 """
# Creating figure
fig = plt.figure()

# Creating subplot
ax = fig.add_subplot(111) # Subplot with 1 row and 1 column at the index 1
plt.show()

Figure 1

上面的代码在add_subplot()方法的帮助下给图fig添加了一个单独的情节。我们得到的输出是一个空白图，轴的范围从 0 到 1，如上所示。在 Python matplotlib 中，我们可以使用更多的内置方法自定义绘图。让我们添加标题、X 轴标签、Y 轴标签，并在两个轴上设置限制范围。下面的代码片段说明了这一点。

""" Example 2 """
fig = plt.figure()

# Creating subplot/axes
ax = fig.add_subplot(111)

# Setting axes/plot title
ax.set_title('An Axes Title')

# Setting X-axis and Y-axis limits
ax.set_xlim([0.5, 4.5])
ax.set_ylim([-3, 7])

# Setting X-axis and Y-axis labels
ax.set_ylabel('Y-Axis Label')
ax.set_xlabel('X-Axis Label')

# Showing the plot
plt.show()

Figure 2

Python Matplotlib 的对象通常有许多显式设置器，即以set_<something>开头并控制特定选项的方法。使用显式设置器设置每个选项变得重复，因此我们可以使用如下所示的set方法直接在轴上设置所有需要的参数:

""" Example 2 using the set method """
fig = plt.figure()

# Creating subplot/axes
ax = fig.add_subplot(111)

# Setting title and axes properties
ax.set(title='An Axes Title', xlim=[0.5, 4.5], ylim=[-3, 7], ylabel='Y-Axis Label', xlabel='X-Axis Label')

plt.show()

set方法不适用于Axes；它或多或少适用于所有 Python matplotlib 对象。

上面的代码片段输出与上面的图 2 相同，使用set方法将所有需要的参数作为实参传递给它。

轴方法 v/s pyplot

有趣的是，Python Matplotlib 中 axes 对象的几乎所有方法都作为一个方法存在于pyplot模块中。例如，我们可以调用plt.xlable('X-Axis Label')来设置 X 轴的标签( plt是pyplot ) 的别名)，进而调用当前轴上的ax.set_xlabel('X-Axis Label')。

""" Example 3 """
# Creating subplots, setting title and axes labels using `pyplot`
plt.subplots()
plt.title('Plot using pyplot')
plt.xlabel('X-Axis Label')
plt.ylabel('Y-Axis Label')
plt.show()

Figure 3

上面的代码更简单一些，用更少的变量来构建一个图。它使用隐式调用轴的方法进行绘图。然而，如果我们看一看《蟒蛇的禅》(试试import this)，它说:

"Explicit is better than implicit."

虽然非常简单的绘图，加上简短的脚本，将受益于pyplot隐式方法的简洁性，但当绘制更复杂的绘图或在更大的脚本中工作时，我们将希望明确地传递轴和/或图形对象以进行操作。我们将在 Python matplotlib 教程中使用这两种方法，只要它认为合适。

每当我们看到如下内容时:

fig = plt.figure()
ax = fig.add_subplot(111)

可以替换为以下内容:

fig, ax = plt.subplots()

两个版本的代码产生相同的输出。但是，后一个版本更干净。

多轴

一个图形可以有多个Axes。在 Python matplotlib 中，最简单的方法是使用plt.subplots()调用创建一个图形，并自动为其添加轴。轴将位于规则的网格系统中。举个例子，

""" Example 4 """
# Creating subplots with 2 rows and 2 columns
fig, axes = plt.subplots(nrows=2, ncols=2)
plt.show()

运行上述代码后，Python Matplotlib 将生成一个图形，其中添加了四个子图形，排列在两行两列中，如下所示:

Figure 4

这里返回的axes对象将是一个 2D-NumPy 数组，数组中的每一项都是一个支线剧情。因此，当我们想要使用这些轴中的一个时，我们可以索引它并使用该项的方法。让我们使用 axes 方法为每个子情节添加标题。

""" Example 5 """
# Create a figure with four subplots and shared axes
fig, axes = plt.subplots(nrows=2, ncols=2, sharex=True, sharey=True)
axes[0, 0].set(title='Upper Left')
axes[0, 1].set(title='Upper Right')
axes[1, 0].set(title='Lower Left')
axes[1, 1].set(title='Lower Right')
plt.show()

上面的代码创建了一个有四个子情节并共享 X 和 Y 轴的图形。轴以行和列的方式在子情节中共享。然后我们使用set方法为每个子情节设置一个标题。子情节以顺时针方式排列，每个子情节具有唯一的索引。输出如下所示:

Figure 5

在 Python Matplotlib 中绘制数据

到目前为止，在这个 Python matplotlib 教程中，我们已经讨论了很多关于布局的内容，但是我们还没有真正讨论任何关于绘制数据的内容。Python Matplotlib 有各种绘图功能。比我们将在这里讨论和涵盖的要多得多。然而，一开始，一份完整的名单或画廊 1 可能会让人有些不知所措。因此，我们将压缩它，并试图从简单的绘图开始，然后走向更复杂的绘图。pyplot的plot方法是 Python Matplotlib 中最广泛使用的绘制数据的方法之一。调用plot方法的语法如下所示:

plot([x], y, [fmt], data=None, **kwargs)

点或线节点的坐标由 x 和 y 给出。可选参数 fmt 是定义颜色、市场和风格等基本格式的便捷方式。在 Python 中,plot方法用于绘制几乎任何类型的数据。它告诉 Python 要绘制什么以及如何绘制，还允许定制要生成的图，如颜色、类型等。

线形图

在 Python matplotlib 中，可以使用plot方法绘制线图。它以线条和/或标记绘制 Y 与 X 的关系。下面我们讨论几个画线的场景。为了绘制直线，我们提供了分别沿 X 和 Y 轴绘制的坐标，如下面的代码片段所示。

""" Example 6 """
# Defining coordinates to be plotted on X and Y axes respectively
x = [1.3, 2.9, 3.1, 4.7, 5.6, 6.5, 7.4, 8.8, 9.2, 10]
y = [95, 42, 69, 11, 49, 32, 74, 62, 25, 32]

# Plot lists 'x' and 'y'
plt.plot(x, y)

# Plot axes labels and show the plot
plt.xlabel('X-axis Label')
plt.ylabel('Y-axis Label')
plt.show()

上面的代码沿着 X 轴绘制了列表x中的值，沿着 Y 轴绘制了列表y中的值。输出如下所示:

Figure 6

对plot的调用采用尽可能少的参数，即仅 Y 轴的值。在这种情况下，Python Matplotlib 会隐式地将列表y中元素的索引视为 X 轴的输入，如下例所示:

""" Example 7 """
# Defining 'y' coordinates
y = [95, 42, 69, 11, 49, 32, 74, 62, 25, 32]

# Plot list 'y'
plt.plot(y)

# Plot axes labels and show the plot
plt.xlabel('Index Values')
plt.ylabel('Elements in List Y')
plt.show()

这里，我们定义了一个名为y的列表，其中包含了要绘制在 Y 轴上的值。输出如下所示:

Figure 7

上面创建的图使用默认的线条样式和颜色。在plot方法中的可选参数 fmt 是一种定义基本格式的便捷方式，比如颜色、标记和线条样式。它是由颜色、标记和线条组成的快捷字符串符号:

fmt = '[color][marker][line]'

每个都是可选的。如果未提供，则使用样式周期中的值。我们在下面的例子中使用这个符号来改变线条颜色:

""" Example 8 """
# Plot line with green color
plt.plot(y, 'g')

# Plot axes labels and show the plot
plt.xlabel('Index Values')
plt.ylabel('Elements in List Y')
plt.show()

Figure 8

按照 fmt 字符串符号，我们使用字符g将线条的颜色改为绿色，这是指线条的颜色。同样，使用如下所示的相同符号添加标记:

""" Example 9 """
# Plot continuous green line with circle markers
plt.plot(y, 'go-')

# Plot axes labels and show the plot
plt.xlabel('Index Values')
plt.ylabel('Elements in List Y')
plt.show()

Figure 9

这里， fmt 参数g指绿色，o指圆形标记，-指要绘制的连续线。这种格式化技术允许我们以任何我们喜欢的方式格式化一个线图。可以通过调整 fmt 字符串中的标记参数来改变标记样式，如下所示:

""" Example 10 """
# Plot continuous green line with circle markers
plt.plot(y, 'g*-')

# Plot axes labels and show the plot
plt.xlabel('Index Values')
plt.ylabel('Elements in List Y')
plt.show()

figure_10

在上面的图中，线条和标记共享相同的颜色，即由 fmt 字符串指定的绿色。如果我们要用不同的颜色绘制线条和标记，我们可以使用多种plot方法来达到同样的效果。

""" Example 11 """
# Plot list 'y'
plt.plot(y, 'g')

# Plot red circle markers
plt.plot(y, 'ro')

# Plot axes labels and show the plot
plt.xlabel('Index Values')
plt.ylabel('Elements in List Y')
plt.show()

Figure 11

上面的代码沿着红色圆圈标记绘制线条。这里，我们首先使用默认样式绘制线条，然后尝试使用属性r表示红色和属性o表示圆形来绘制标记。在同样的线上，我们可以使用同样的技术绘制多组数据。下面给出的示例在同一个图上绘制了两个列表。

""" Example 12 - Technique 1"""
# Define two lists
y = [95, 42, 69, 11, 49, 32, 74, 62, 25, 32]
y2 = [35, 52, 96, 77, 36, 66, 50, 12, 35, 63]

# Plot lists and show them
plt.plot(y, 'go-')
plt.plot(y2, 'b*--')

# Plot axes labels and show the plot
plt.xlabel('Index Values')
plt.ylabel('Elements in Lists')
plt.show()

Figure 12

我们可以使用如下所示的不同技术获得如上所示的相同结果:

""" Example 12 - Technique 2"""
# Plot lists and show them
plt.plot(y, 'go-', y2, 'b*--')

# Plot axes labels and show the plot
plt.xlabel('Index Values')
plt.ylabel('Elements in Lists')
plt.show()

从本质上讲，plot方法使得绘制顺序数据结构变得非常容易，比如 list、NumPy 数组、pandas 系列等。类似于绘制列表，我们可以通过plot方法直接绘制 NumPy 数组。让我们画出 NumPy 一维数组。因为我们直接在 IPython 控制台中执行代码，所以不需要调用plt.show(),因此，在后面的例子中我们也不会调用它。但是，记住，在编写 Python 代码展示剧情的同时，调用它是绝对必要的。

""" Example 13 """
# Importing NumPy library
import numpy as np

# Drawing 30 samples from a standard normal distribution into an array 'arr'
arr = np.random.normal(size=30)

# Plotting 'arr' with dashed line-style and * markers
plt.plot(arr, color='teal', marker='*', linestyle='dashed')

Figure 13

在上面的例子中，我们从正态分布中抽取 30 个样本到数组arr中，数组arr又被绘制成虚线和星号标记。绘制二维数组遵循相同的模式。我们为一个plot方法提供一个二维数组来绘制它。

""" Example 14 """
# Creating a two dimensional array 'arr_2d' with 40 samples and shape of (20, 2)
arr_2d = np.random.normal(size=40).reshape(20, 2)

# Plotting the array
plt.plot(arr_2d)

figure_14

现在让我们把注意力转移到绘制 pandas 数据结构上。pandas 库使用 Python matplotlib 标准惯例直接从其数据结构进行绘图。pandas 还提供了一个plot方法，它相当于 Python matplotlib 提供的方法。因此，可以从 pandas 系列和 DataFrame 对象中直接调用plot方法。Series 和 DataFrame 上的plot方法只是对plt.plot()的简单包装。以下示例说明了如何绘制熊猫系列对象:

""" Figure 15 """
# Importing necessary libraries
import pandas as pd
import numpy as np

# Creating pandas Series with 50 samples drawn from normal distribution
ts = pd.Series(np.random.normal(size=50),
               index=pd.date_range(start='1/1/2019', periods=50))

# Plotting pandas Series
ts.plot()

Figure 15

在上面的例子中，我们直接在熊猫系列对象ts上调用plot方法。或者，我们可以打电话给plt.plot(ts)。调用ts.plot()相当于调用plt.plot(ts)，两次调用都会产生几乎相同的输出，如上图所示。此外，pandas 对象上的plot()方法支持plt.plot()支持的几乎所有格式化属性。例如，在具有color属性的熊猫对象上调用plot方法会产生一个带有其值所提到的颜色的绘图。如下所示:

""" Figure 16 """
# Plotting pandas Series in green color
ts.plot(color='green')

Figure 16

接下来，pandas DataFrame 对象也遵循同样的符号，在 DataFrame 中可视化数据变得更加直观，不再那么奇怪。在我们尝试直接从数据帧绘制数据之前，让我们创建一个新的数据帧并填充它。我们获取 AAPL 股票交易所的股票数据，在 Python matplotlib 教程的剩余部分中，我们将使用这些数据进行说明。

""" Script to fetch AAPL data from a web resource """
# Import libraries
import pandas as pd

# Fetch data 
data = pd.read_csv('https://bit.ly/2WcsJE7', index_col=0, parse_dates=True)

dataframe data将包含以日期为索引的股票数据。下载数据的摘录如下所示:

日期 打开 高的 低的 关闭 卷 除息 ...
2018-03-27 One hundred and seventy-three point six eight One hundred and seventy-five point one five One hundred and sixty-six point nine two One hundred and sixty-eight point three four Thirty-eight million nine hundred and sixty-two thousand eight hundred and ninety-three Zero ...
2018-03-26 One hundred and sixty-eight point zero seven One hundred and seventy-three point one One hundred and sixty-six point four four One hundred and seventy-two point seven seven Thirty-six million two hundred and seventy-two thousand six hundred and seventeen Zero ...
2018-03-23 One hundred and sixty-eight point three nine One hundred and sixty-nine point nine two One hundred and sixty-four point nine four One hundred and sixty-four point nine four Forty million two hundred and forty-eight thousand nine hundred and fifty-four Zero ...

现在我们可以通过调用plot方法来绘制data数据帧的任何列。在下面给出的例子中，我们从数据帧的Volume列绘制了最近的 100 个数据点:

""" Figure 17 """
# Plot volume column
data.Volume.iloc[:100].plot()

Figure 17

使用 dataframe，plot方法可以方便地绘制所有带标签的列。换句话说，如果我们绘制多列，它也会绘制每列的标签。

""" Figure 18 """
data[['AdjOpen', 'AdjClose']][:50].plot()

Figure 18

在 pandas 数据结构上调用plot方法时，默认情况下会生成一个线图。然而，它也可以生成各种其他图表，我们将在本 Python matplotlib 教程的后面看到。说到这里，让我们继续绘制散点图。

散点图

在 Python matplotlib 中，散点图用于可视化两个不同数据集之间的关系。Python Matplotlib 在pyplot子模块中提供了scatter方法，使用该方法可以生成散点图。

  • plt.scatter用不同的标记尺寸和/或颜色生成 y 对 x 的散点图。

x 和 y 参数是数据位置，可以是类似数组的顺序数据结构。有些情况下，我们的数据格式允许我们用字符串访问特定的变量。比如 Python 字典或者熊猫 dataframe。Python Matplotlib 允许我们向scatter方法提供这样一个带有data关键字参数的对象，以便直接从中绘图。下面的例子用一个字典说明了这一点。

""" Figure 19 """
# Creating a dictionary with three key-value pairs
dictionary = {'a': np.linspace(1, 100, 50),
              'c': np.random.randint(0, 50, 50),
              'd': np.abs(np.random.randn(50)) * 100}

# Creating a new dictionary key-value pair
dictionary['b'] = dictionary['a'] * np.random.rand(50)

# Plotting a scatter plot using argument 'data'
plt.scatter('a', 'b', c='c', s='d', data=dictionary)

# Labeling the plot and showing it
plt.xlabel('A Data Points')
plt.ylabel('B Data Points')
plt.show()

Figure 19

在上面的代码中，我们创建了一个包含四个键值对的字典dictionary。键a和b中的值包含要绘制在散点图上的 50 个随机值。关键字c包含五十个随机整数，关键字d包含五十个正浮点数，分别代表每个散点图数据点的颜色和大小。然后，调用plt.scatter连同所有键和dictionary作为data的值。调用中的参数c表示要使用的颜色，参数s表示数据点的大小。这些参数c和s是可选的。当我们省略这些可选参数时，将绘制一个具有相同颜色和大小的简单散点图，如下例所示:

""" Figure 20 """
# Creating a scatter plot without color and same
plt.scatter(dictionary['a'], dictionary['b'])

# Labeling the plot and showing it
plt.xlabel('A Data Points')
plt.ylabel('B Data Points')
plt.show()

Figure 20

为了更好地理解散点图的工作原理，让我们求助于我们的老朋友:列表x和y，它们是我们之前在学习线图时定义的，并在其上构建散点图。为了提醒我们，我们在下面重新定义了相同的列表:

# Data points for scatter plot
x = [1.3, 2.9, 3.1, 4.7, 5.6, 6.5, 7.4, 8.8, 9.2, 10]
y = [95, 42, 69, 11, 49, 32, 74, 62, 25, 32]

除了这些列表之外，我们将定义另外两个 NumPy 数组color和size，它们在绘制散点图时分别确定每个数据点的颜色和大小。

# Arrays which defines color and size of each data point
color = np.random.rand(10)
size = np.random.randint(50, 100, 10)

现在我们已经准备好数据点，我们可以绘制一个散点图，如下所示:

""" Figure 21 """
# Creating a scatter plot
plt.scatter(x, y, c=color, s=size)

# Labeling the plot and showing it
plt.xlabel('Values from list x')
plt.ylabel('Values from list y')
plt.show()

散点图将包含每个具有不同颜色和大小的数据点(因为它们是随机生成的)。输出如下所示:

Figure 21

在金融领域，散点图广泛用于直观地确定两个数据集之间的关系。也就是说，在具备散点图的工作知识后，现在让我们继续学习 Python matplotlib 教程，绘制一个熊猫数据框架data中 AAPL 股票AdjOpen和AdjClose价格的散点图。当直接从 pandas dataframe 绘制数据时，我们几乎总是可以在 pandas 上使用plot方法来绘制各种图。也就是说，我们可以在数据框上直接使用plot方法来绘制散点图，甚至就像线图一样。但是，我们需要指定我们对使用参数kind='scatter'绘制散点图感兴趣，如下所示:

""" Figure 22 """
# Plotting a scatter plot of 'AdjOpen' and 'AdjClose' of AAPL stock
data.plot(x='AdjOpen', y='AdjClose', kind='scatter')
plt.show()

有趣的是，我们只需要为x和y坐标以及参数kind指定数据帧data的列名，结果如下所示:

Figure 22

通过使用散点图可视化价格模式，可以推断开盘价和收盘价正相关。此外，我们可以使用plt.scatter方法生成相同的图。

""" Method 1 """
plt.scatter(x='AdjOpen', y='AdjClose', data=data)
plt.show()

""" Method 2 """
plt.scatter(x=data['AdjOpen'], y=data['AdjClose'])
plt.show()

方法一使用指定数据源的参数data，而第二种方法直接使用数据帧切片，因此不需要指定参数data。

直方图

直方图是数据分布的图形表示。它是一种条形图，是一种可视化数据频率分布的强大工具，几乎任何受众都可以轻松理解。要构建直方图，第一步是对数据值的范围进行分类，将整个范围分成一系列区间，最后计算每个区间内有多少个值。这里，仓是连续的且不重叠的。换句话说，直方图以一些组的形式显示数据。所有箱/组在 X 轴上，Y 轴显示每个箱/组的频率。

Python matplotlib 库提供了一种非常方便的绘制直方图的方法。为了创建直方图，我们使用了matplotlib库的pyplot子模块的hist方法。让我们从创建一个简单的直方图开始。

""" Figure 23 """
# Data values for creating a histogram
y = [95, 42, 69, 11, 49, 32, 74, 62, 25, 32]

# Creating a histogram
plt.hist(y)
plt.xlabel('Bins')
plt.ylabel('Frequency')
plt.show()

Figure 23

在 Python matplotlib 中，这是用最少的参数绘制直方图的最简单的代码。我们创建一个值的范围，并简单地将其提供给hist方法，让它执行剩下的事情(创建库，将每个值隔离到相应的库，绘图等。).hist方法也将bins作为可选参数。如果指定了此参数，将根据指定的值创建容器，否则，将自行创建容器。为了说明这一点，我们在上面的代码中明确指定了箱的数量并生成了绘图。修改后的代码和输出如下所示:

""" Figure 24 """
# Data values for creating a histogram
y = [95, 42, 69, 11, 49, 32, 74, 62, 25, 32]

# Creating a histogram
plt.hist(y, bins= 20)
plt.xlabel('Bins')
plt.ylabel('Frequency')
plt.show()

Figure 24

我们得到的输出非常直接。数字32在列表y中出现两次，直观反映。我们将仓的数量指定为20，因此，hist方法试图将整个范围的值分成 20 个仓，并将它们绘制在 X 轴上。与plot方法类似，hist方法也将任何顺序数据结构作为其输入，并绘制其直方图。让我们尝试在 Python matplotlib 中生成一个数组的直方图，它从标准正态分布中抽取样本。

""" Figure 25 """
# Creating an array
array = np.random.normal(0, 1, 10000)

# Creating a histogram
plt.hist(array)
plt.xlabel('Bins')
plt.ylabel('Frequency')
plt.show()

Figure 25

我们得到的输出表明，数据分布确实类似于正态分布。除了bins参数外，其他可以提供给hist的参数有color和histtype。有很多论点可以提供，但我们将保持我们的讨论仅限于这几个论点。使用color参数可以改变直方图的颜色。histtype参数采用一些预定义的值，如bar、barstacked、step和stepfilled。下面的示例说明了这些参数的用法。

""" Figure 26 """
# Creating an array
array = np.random.normal(0, 1, 10000)

# Creating a histogram and plotting it
plt.hist(array, color='purple', histtype='step')
plt.xlabel('Bins')
plt.ylabel('Frequency')
plt.show()

Figure 26

除了到目前为止讨论的可选参数，需要注意的一个参数是orientation。该参数采用两个值中的任意一个:horizontal或vertical。默认为vertical。

""" Figure 27 """
# Creating an array
array = np.random.normal(0, 1, 10000)

# Creating a histogram and plotting it
plt.hist(array, color='teal', orientation='horizontal')
plt.xlabel('Frequency')
plt.ylabel('Bins')
plt.show()

Figure 27

现在，我们将注意力转移到直接从 Python matplotlib 中的 pandas 数据帧绘制直方图上。同样，pandas 中的plot方法为 Python matplotlib 中的hist函数提供了一个包装器，就像散点图一样。为了绘制直方图，当直接从 dataframe 调用plot时，我们需要用值hist指定参数kind。我们将使用包含 AAPL 股票历史数据的相同数据框架data。

""" Figure 28 """
# Method 1
# Creating a histogram using a dataframe method
data['Volume'].plot(kind='hist')
plt.show()

# Method 2
plt.hist(data['Volume'])
plt.ylabel('Frequency')
plt.show()

figure_28

在第一种方法中，我们直接在用Volume列切片的数据帧data上调用plot方法。而在第二种方法中，我们使用由matplotlib.pyplot模块提供的hist方法来绘制直方图。如上所示，两种方法绘制的结果相同。在 Python matplotlib 教程的下一部分，我们将学习一些有趣的东西，如何定制你自己的情节。

使用 Python Matplotlib 进行地块定制

现在我们已经很好地理解了绘制各种类型的图表及其基本格式化技术，我们可以更深入地研究一些格式化技术。我们已经了解到 Python matplotlib 本身不添加任何样式组件。默认情况下，它会绘制一个简单的普通图表。作为用户，我们需要指定我们需要的任何定制。我们从一个简单的线图开始，并将继续改进。以下示例显示了我们在数据框架data中获得的 AAPL 股票收盘价。

""" Figure 29 """
# Extracting close prices from the dataframe
close_prices = data['AdjClose']

# Plotting the close prices
plt.plot(close_prices)
plt.show()

figure_29

这里，close_prices是使用plot方法绘制的熊猫系列对象。然而，X 轴上的值是我们不想要的。它们都是相互重叠的。这是因为plot方法没有为每个日期找到足够的空间。解决这个问题的一个方法是旋转 X 轴上的值，使其看起来更好。

""" Figure 30 """
plt.plot(close_prices)

# Rotating the values along x-axis to 45 degrees
plt.xticks(rotation=45)
plt.show()

figure_30

xticks方法和rotation参数用于沿 x 轴旋转数值/刻度名称。可用于解决重叠问题的另一种方法是增加绘图的图形大小，以便 Python matplotlib 可以轻松显示没有重叠的值。如下例所示:

""" Figure 31 """
# Creating a figure with the size 10 inches by 5 inches
fig = plt.figure(figsize=(10, 5))
plt.plot(close_prices)
plt.show()

figure_31

类似地，Python matplotlib 提供了yticks方法，可用于定制 Y 轴上的值。除了rotation参数，还有一堆其他参数可以提供给xticks和yticks来进一步定制它们。在下面的示例中，我们使用这些方法中的适当参数来更改沿轴刻度的字体大小、颜色和方向:

""" Figure 32 """
# Creating a figure, setting its size and plotting close prices on it
fig = plt.figure(figsize=(10, 5))
plt.plot(close_prices, color='purple')

# Customizing the axes
plt.xticks(rotation=45, color='teal', size=12)
plt.yticks(rotation=45, color='teal', size=12)

# Setting axes labels
plt.xlabel('Dates', {'color': 'orange', 'fontsize':15})
plt.ylabel('Prices', {'color': 'orange', 'fontsize':15})
plt.show()

figure_32

除了轴值，我们还改变了轴标签的颜色和字体大小。使用各种参数可以进行许多其他定制，Python matplotlib 提供了完全的灵活性，可以根据个人需要创建图表。上图中缺少的两个主要组件是标题和图例，可以分别使用方法title和legends来提供。同样，与其他方法一样，可以用各种方式定制它们，但是我们将只讨论几个重要的参数。在上面的代码中添加这两个方法会产生下面的图:

""" Figure 33 """
# Showing the legend and setting the title of plot
plt.legend()
plt.title('AAPL Close Prices', color='purple', size=20)

figure_33

Python matplotlib 中另一个可以添加到图形中的重要特性是使用采用True或False的grid方法在图形中绘制网格。如果为真，则绘制网格，否则不绘制网格。

""" Figure 34 """
# Adding the grid to the plot
plt.grid(True)

figure_34

axhline方法允许我们在图中添加一条穿过轴的水平线。例如，我们可以考虑添加收盘价的平均值来显示股票在整个持续时间内的平均价格。可以使用 Python matplotlib 中的axhline方法添加。平均值的计算及其对原始图的添加如下所示:

""" Figure 35 """
# Importing NumPy library
import numpy as np

# Calculating the mean value of close prices
mean_price = np.mean(close_prices)

# Plotting the horizontal line along with the close prices
plt.axhline(mean_price, color='r', linestyle='dashed')

figure_35

现在我们有了图中收盘价的平均值，第一次看图表的人可能会想这条红线传达了什么？因此，有必要明确提及这一点。为此，我们可以使用由matplotlib.pyplot模块提供的text方法在图上的任何地方绘制文本。

""" Figure 36 """
# Importing DateTime from DateTime library
from datetime import datetime

# Plotting text on date 2014-1-7 and price 120
plt.text(datetime(2014,1,7), 120, 'Mean Price', size=15, color='r')

text方法有三个强制参数:x、y和t，分别指定 X 和 Y 轴上的坐标和文本。此外，我们使用来自datetime库中的datetime子模块来指定 X 轴上的日期，因为我们正在生成的图在 X 轴上有日期。下图是显示平均价格的文字图表:

figure_36

使用所有这些定制技术，我们已经能够将看起来沉闷的价格系列图演变成一个漂亮而有吸引力的图形，不仅易于理解，而且还可以看得见。然而，我们仅限于绘制一张图表。让我们振作起来，学习将这些新获得的定制技术应用于多个地块。

使用 Python Matplotlib 的多个图

在 Python matplotlib 教程的开始，我们已经了解到一个图形可以有多个图，这可以通过使用subplots方法来实现。下面的例子显示了 AAPL 股票的价格以及每天的交易量。

""" Figure 37 """

# Extracting volume from the dataframe 'data'
volume = data['AdjVolume']

# Creating figure with two rows and one column
fig, (ax1, ax2) = plt.subplots(nrows=2, ncols=1, sharex=True, figsize=(10, 8))

# Plotting close prices on the first sub-plot
ax1.plot(close_prices, color='purple')
ax1.grid(True)

# Plotting trading volume on the second sub-plot
ax2.bar(volume.index, volume)
ax2.grid(True)

# Displaying the plot
plt.show()

figure_37

首先，我们将data数据帧中的AdjVolume列提取到一个volume中，它恰好是熊猫系列对象。然后，我们创建一个具有两行和一列子图的图形。这是分别使用nrows和ncols参数实现的。sharex参数指定两个子图将共享相同的 x 轴。同样，我们也使用figsize参数指定图形大小。这两个支线剧情分别解包成两个轴:ax1和ax2。一旦我们有了坐标轴，就可以在上面绘制出想要的图表。

接下来，我们使用plot方法绘制close_prices，并使用color参数将其颜色指定为purple。与plot方法类似，Python matplotlib 提供了bar方法来绘制条形图，该方法采用两个参数:第一个参数绘制在 X 轴上，第二个参数绘制在 y 轴上。对于我们的示例，X 轴上的值恰好是一个日期(由volume.index指定)，Y 轴上每个条形的值是使用最近创建的volume系列提供的。之后，我们在两个地块上绘制网格。最后，我们显示两个图。从上面可以看出，Python matplotlib 呈现了一个不错的图表。但是，它遗漏了一些关键部分，如标题、图例等。

""" Figure 38 """
# Creating figure with multiple plots
fig, (ax1, ax2) = plt.subplots(nrows=2, ncols=1, sharex=True, figsize=(10, 8))
ax1.plot(close_prices, color='purple', label='Prices')
ax1.grid(True)

# Setting the title of a first plot
ax1.set_title('Daily Prices')

# Setting the legend for the first plot
ax1.legend()

ax2.bar(volume.index, volume, label='Volume')
ax2.grid(True)

# Setting the title of a second plot
ax2.set_title('Volume')

# Setting the legend for the second plot 
ax2.legend()

plt.show()

figure_38

这里，我们使用legend方法在两个图中设置图例。绘制每个图时，图例将打印由label参数指定的值。set_title用于设定每个情节的标题。之前在处理单一剧情的时候，我们已经用了title的方法来设置标题。但是，对于多个情节，情况就不一样了。

Python matplotlib 提供的另一个方便的方法是tight_layout方法，它自动调整子情节之间的填充和其他类似参数，以便它们适合图形区域。

""" Figure 39 """
# Setting layout
plt.tight_layout()

# Setting label on the x-axis
plt.xlabel('Dates')
plt.show()

上面的代码明确指定了 x 轴上的布局和标签，这导致了下面的图表。

figure_39

除了所有这些定制，Python matplotlib 还提供了许多易于使用的预定义样式。例如，有一个预定义的样式叫做“ggplot”，它模仿了 ggplot (一个流行的 R 语言绘图包)的美学。要更改正在渲染的绘图的样式，需要使用以下代码显式指定新样式:

plt.style.use('ggplot')

将样式设置为“使用”时，此后渲染的所有地块将使用相同的新设置样式。要列出所有可用的样式，请执行以下代码:

plt.style.available

让我们将样式设置为预定义的样式之一，称为‘fivethirtyeight’，并绘制图表。

plt.style.use('fivethirtyeight')
fig, (ax1, ax2) = plt.subplots(nrows=2, ncols=1, sharex=True, figsize=(10, 8))

ax1.plot(close_prices, color='purple', label='Prices')
ax1.grid(True)
ax1.set_title('Daily Prices')
ax1.legend()

ax2.bar(volume.index, volume, label='Volume')
ax2.grid(True)
ax2.set_title('Traded Volume')
ax2.legend()

plt.tight_layout()

plt.xlabel('Dates')
plt.show()

figure_40

通过改变样式，我们可以清楚地了解到样式在绘制图表时是如何起到改变图表外观的重要作用的。

我们将学习的最后一个方法是用于在本地机器上保存图形的savefig方法。它采用将被保存的图形的名称。下图说明了这一点:

plt.savefig('AAPL_chart.png')

执行上面的代码将会用名称AAPL_chart.png保存我们在上面绘制的图表。

结论

因此，在这个 Python matplotlib 教程中，我们从图形和绘图的基础开始，逐步学习各种类型的图表及其本质，最后，我们学习了定制，并先睹为快地在同一个图表中绘制多个绘图。

重申一下，Python matplotlib 教程是从 Python 基础手册中摘录的，该手册是为这两者而创建的；刚开始使用 Python 的新手，以及有成就的交易者，他们可以在编写策略时使用它作为方便的参考。

请在下面的评论中告诉我们你是否喜欢这篇文章和任何其他反馈。

免责声明:股票市场的所有投资和交易都有风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。

Python Numpy 教程:安装、数组和随机采样

原文：https://blog.quantinsti.com/python-numpy-tutorial-installation-arrays-random-sampling/

杰伊·帕尔马

NumPy ，数字 Python 的首字母缩写，是一个用 Python 高效执行科学计算的包。它包括随机数生成能力，基本线性代数函数等等。

今天我们将学习 Python Numpy 模块的基础知识以及理解一些代码。这篇博客文章摘自 Python 基础手册，目的很简单，就是让读者理解 Python 语言的美丽和简单。

本文的内容包括:

  • [安装 NumPy](#Installing Numpy)
  • [NumPy 数组](#NumPy Arrays)
  • [使用内置函数创建数组](#Array creation using built-in functions)
  • [在 NumPy 中随机抽样](#Random Sampling in NumPy)
  • [数组属性和方法](#Array Attributes and Methods)
  • [数组操作](#Array Manipulation)
  • [数组索引和迭代](#Array Indexing and Iterating)
  • 总结
  • 结论

NumPy 不是 Python 标准库的一部分，因此，与任何其他此类库或模块一样，它需要安装在工作站上才能使用。

根据用户使用的 Python 发行版，可以通过命令提示符、conda 提示符或终端使用以下命令来安装。

pip install numpy

需要注意的一点是，如果我们使用 Anaconda 发行版来安装 Python，大部分库(如 NumPy、pandas、scikit-learn、matplotlib 等。)是预装的。

注意: 如果我们使用 Python 或 iPython 控制台来安装 NumPy 库，安装它的命令前面会有字符！

安装后，我们可以通过使用 import 语句将其导入到我们的程序中来使用。实际的导入方式如下所示:

import numpy as np

这里，NumPy 库是用一个别名 np 导入的，因此可以方便地使用其中的任何功能。我们将在本节的所有示例中使用这种形式的别名。

Python 列表是一个非常强大的顺序数据结构，具有一些漂亮的特性，比如索引子设置和遍历。但是列表缺少一个重要的特性，即以高效的方式对整个元素集合执行操作。

例如，考虑我们计算前 5 天的 PCR(看跌期权比率)的情况。比方说，我们将卖出期权和买入期权分别存储在 call_vol 和 put_vol 列表中。

然后，我们通过将卖出量除以买入量来计算 PCR，如以下脚本所示:

put_vol = [52.89, 45.14, 63.84, 77.1, 74.6] # Put volume in lacs

call_vol = [49.51, 50.45, 59.11, 80.49, 65.11] # Call volume in lacs

# Computing Put Call Ratio (PCR)
put_vol / call_vol
Traceback (most recent call last):

  File "<ipython-input-12-9f9b38fcc5f4>", line 1, in <module>
    put_vol / call_vol

TypeError: unsupported operand type(s) for /: 'list' and 'list'

不幸的是，Python 在计算 PCR 值时抛出了一个错误，因为它不知道如何在列表上进行计算。我们可以通过遍历列表中的每一项并分别计算每天的 PCR 来做到这一点。然而，这样做既低效又无聊。一种更好的解决方案是使用 Python NumPy 数组，这是常规 Python 列表的替代方法。

让我们使用 Python NumPy 数组执行同样的操作。为此，我们使用 NumPy 包中的 array()函数，并创建 put_vol 和 call_vol 列表的 Python NumPy 版本。
中的

# Importing NumPy library
import numpy as np

# Creating arrays
n_put_vol = np.array(put_vol)

n_call_vol = np.array(call_vol)

n_put_vol

Out[]
array([52.89, 45.14, 63.84, 77.1 , 74.6 ])

In[]
n_call_vol

Out[]
array([49.51, 50.45, 59.11, 80.49, 65.11])

这里我们有两个数组 n_put_vol 和 n_call_vol，分别存放 put 和 call 的音量。

现在，我们可以用一行来计算 PCR:
In[]

# Computing Put Call Ratio (PCR)
pcr = n_put_vol / n_call_vol

pcr

Out[]

array([1.06826904, 0.89474727, 1.0800203 , 0.95788297, 1.14575334])

这一次成功了，计算是按元素进行的。PCR 数组中的第一个观察值是通过将 n_put_vol 中的第一个元素除以 n_call_vol 数组中的第一个元素来计算的，依此类推。

Python NumPy 处理数组就像处理标量一样。但是我们需要注意这里。Python NumPy 可以很容易地做到这一点，因为它假设数组只能包含单一类型的值。

要么是整数数组，要么是浮点数数组，要么是布尔值数组等等。如果我们试图创建一个不同类型的数组，就像下面提到的那样，得到的 NumPy 数组将只包含一种类型。

字符串在下面的情况下:

在[]

np.array([1, 'Python', True])

Out[]

array(['1', 'Python', 'True'], dtype='<U11')

注意: NumPy 数组被创建为同构数组，这是考虑到可以对它们执行的数学运算。对于异构数据集，这是不可能的。

在上面给出的例子中，一个整数和一个布尔值都被转换为字符串。NumPy 数组是一种新型的数据结构类型，类似于我们之前看到的 Python 列表类型。这也意味着它有自己的方法，这些方法的行为与其他类型不同。

让我们在 Python list 和 NumPy 数组上实现+操作，看看它们有什么不同。
中的

# Creating lists
list_1 = [1, 2, 3]

list_2 = [5, 6, 4]

# Adding two lists
list_1 + list_2

Out[]

[1, 2, 3, 5, 6, 4]

在[]

# Creating arrays
arr_1 = np.array([1, 2, 3])

arr_2 = np.array([5, 6, 4])

# Adding two arrays
arr_1 + arr_2

Out[]

array([6, 8, 7])

从上面的例子中可以看出，使用 list_1 和 list_2 执行+运算，列表元素被粘贴在一起，生成一个包含 6 个元素的列表。

另一方面，如果我们用 NumPy 数组做这件事，Python 会对数组做元素求和。

N 维数组

到目前为止，我们已经使用了两个数组:n_put_vol 和 n_call_vol。如果我们要使用 type()检查其类型，Python 会告诉我们它们属于 numpy.ndarray 类型，如下所示:

In[]

# Checking array type
type(n_put_vol)

Out[]

numpy.ndarray

根据我们收到的输出，可以推断它们的数据类型是 ndarray，它代表 Python NumPy 中的 n 维数组。

这些数组都是一维数组，但是 Python NumPy 也允许我们创建二维、三维等等。出于学习目的，我们将坚持二维。

我们可以从一个常规的 Python 列表中创建一个 2D(二维)Python NumPy 数组。

让我们为所有的 put 和 call 卷创建一个数组。中的

# Recalling put and call volumes lists
put_vol

Out[]

[52.89, 45.14, 63.84, 77.1, 74.6]

在[]

call_vol

Out[]

[49.51, 50.45, 59.11, 80.49, 65.11]

在[]

# Creating a two-dimensional array
n_2d = np.array([put_vol, call_vol]) 


n_2d

Out[]

array([[52.89, 45.14, 63.84, 77.1 , 74.6 ],
       [49.51, 50.45, 59.11, 80.49, 65.11]])

我们看到 n_2d 数组是一个矩形的数据结构。np.array 创建函数中提供的每个列表对应于二维 NumPy 数组中的一行。对于 2D 数组，NumPy 规则同样适用:一个数组只能包含一种类型。

如果我们在上面的数组定义中改变一个浮点值，所有的数组元素都会被强制转换成字符串，以一个同质数组结束。我们可以把 2D 数组看作是链表的高级版本。我们可以用 2D 进行元素运算，就像我们看到的一维数组一样。

Anchor 创建数组

在创建 n_call_vol 和 n_put_vol 数组时提供了显式输入。相比之下，Python NumPy 提供了各种内置函数来创建数组，这些函数的输入将由 Python NumPy 生成。

下面我们讨论几个这样的函数:

1。zeros(shape，dtype=float) 返回给定形状和类型的数组，用零填充。如果 dtype 没有作为输入提供，数组的默认类型将是 float。
中的

# Creating a one-dimensional array
np.zeros(5)

Out[]

array([0., 0., 0., 0., 0.])

在[]

# Creating a two-dimensional array
np.zeros((3, 5))

Out[]

array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]])

在[]

# Creating a one-dimensional array of integer type
np.zeros(5, dtype=int)

out[]array([0, 0, 0, 0, 0])

2。ones(shape，dtype=float) 返回给定形状和类型的数组，用 1 填充。

# Creating a one-dimensional array
np.ones(5)

Out[]

array([1., 1., 1., 1., 1.])

在[]

# Creating a one-dimensional array of integer type
np.ones(5, dtype=int)

Out[]

array([1, 1, 1, 1, 1])

3。full(shape，fill_value，dtype=None) 返回一个给定形状和类型的数组，用输入参数中给定的 fill_value 填充。

在[]

# Creating a one-dimensional array with value as 12
np.full(5, 12)

Out[]

array([12, 12, 12, 12, 12])

在[]

# Creating a two-dimensional array with value as 9
np.full((2, 3), 9)

Out[]

array([[9, 9, 9],
       [9, 9, 9]])

4。arange([start，]stop，[step]) 返回一个数组，其中的值在给定的间隔内均匀分布。这里，开始和步骤参数是可选的。如果提供了它们，Python NumPy 将在计算输出时考虑它们。否则，范围计算从 0 开始。对于所有情况，停止值将被排除在输出之外。

在[]

# Creating an array with only stop argument
np.arange(5)

Out[]

array([0, 1, 2, 3, 4])

在[]

# Creating an array with start and stop arguments
np.arange(3, 8)

Out[]

array([3, 4, 5, 6, 7])

在[]

# Creating an array with given interval and step value as 0.5
np.arange(3, 8, 0.5)

Out[]

array([3\. , 3.5, 4\. , 4.5, 5\. , 5.5, 6\. , 6.5, 7\. , 7.5])

5。linspace(start，stop，num=50，endpoint=True) 返回指定间隔内间隔相等的数字。要返回的样本数由 num 参数指定。可以选择性地排除区间的终点。

在[]

# Creating an evenly spaced array with five numbers within interval 2 to 3
np.linspace(2.0, 3.0, num=5)

Out[]

array([2\.  , 2.25, 2.5 , 2.75, 3\.  ])

在[]

# Creating an array excluding end value
np.linspace(2.0, 3.0, num=5, endpoint=False)

Out[]

array([2\. , 2.2, 2.4, 2.6, 2.8])

在[]

# Creating an array with ten values within the specified interval
np.linspace(11, 20, num=10)

Out[]

array([11., 12., 13., 14., 15., 16., 17., 18., 19., 20.])![Anchor](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/4765334125b448ec4c4bdf8285a1da72.png "Anchor")

除了上面讨论的内置函数，Python NumPy 中还有一个随机子模块，它提供了方便的函数来随机生成数据，并从各种分布中抽取样本。

这里讨论了一些广泛使用的函数。

1。rand([d0，d1，...，dn]) 用于创建一个给定形状的数组，并用[0，1]上均匀分布的随机样本填充它。它只需要积极的论点。如果没有提供参数，则返回单个浮点值。

在[]

# Generating single random number
np.random.rand()

Out[]

0.1380210268817208

在[]

# Generating a one-dimensional array with four random values
np.random.rand(4)

Out[]

array([0.24694323, 0.83698849, 0.0578015 , 0.42668907])

在[]

# Generating a two-dimensional array
np.random.rand(2, 3)

Out[]

array([[0.79364317, 0.15883039, 0.75798628],
       [0.82658529, 0.12216677, 0.78431111]])

2。randn([d0，d1，...，dn]) 用于创建一个给定形状的数组，并用来自标准正态分布的随机样本填充它。

它只接受正参数并生成一个形状数组(d0，d1，...，dn)填充有从均值为 0、方差为 1 的单变量正态分布中采样的随机浮点数。如果没有提供参数，则返回从分布中随机抽样的单个浮点数。

在[]

# Generating a random sample
np.random.randn()

Out[]

0.5569441449249491

在[]

# Generating a two-dimensional array over N(0, 1)
np.random.randn(2, 3)

Out[]

array([[ 0.43363995, -1.04734652, -0.29569917],
       [ 0.31077962, -0.49519421,  0.29426536]])

在[]

# Generating a two-dimensional array over N(3, 2.25)
1.5 * np.random.randn(2, 3) + 3

Out[]

array([[1.75071139, 2.81267831, 1.08075029],
       [3.35670489, 3.96981281, 1.7714606 ]])

3。randint(low，high=None，size=None) 从具有下限(含)和上限(不含)的离散均匀分布中返回一个随机整数。如果 high 为 None(默认值)，则结果从 0 到 low。如果指定了大小，它将返回指定大小的数组。

在[]

# Generating a random integer between 0 and 6
np.random.randint(6)

Out[]

2

在[]

# Generating a random integer between 6 and 9
np.random.randint(6, 9)

7
出[]
入[]

# Generating a one-dimensional array with values between 3 and 9
np.random.randint(3, 9, size=5)

Out[]

array([6, 7, 8, 8, 5])

在[]

# Generating a two-dimensional array with values between 3 and 9
np.random.randint(3, 9, size=(2, 5))

Out[]

array([[5, 7, 4, 6, 4],
       [6, 8, 8, 5, 3]])

4。random(size=None) 返回一个从连续均匀分布中抽取的介于 0 和 1 之间的随机浮点值。

在[]

# Generating a random float
np.random.random()

Out[]

0.6013749764953444

在[]

# Generating a one-dimensional array
np.random.random(3)

Out[]

array([0.69929315, 0.61152299, 0.91313813])

在[]

# Generating a two-dimensional array
np.random.random((3, 2))

Out[]

array([[0.55779547, 0.6822698 ],
       [0.75476145, 0.224952  ],
       [0.99264158, 0.02755453]])

5。binomial(n，p，size=None) 返回从二项式分布中抽取的样本，该分布具有 n 次试验和 p 个成功概率，其中 n 大于 0，p 介于 0 和 1 之间。

在[]

# Number of trials, probability of each trial
n, p = 1, .5

# Flipping a coin 1 time for 50 times
samples = np.random.binomial(n, p, 50)

samples

Out[]

array([1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1,
       0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0,
       0, 1, 0, 0, 1, 0])

6。normal(mu=0.0，sigma=1.0，size=None) 从正态(高斯)分布中抽取随机样本。如果没有提供参数，将从 N(0，1)中抽取一个样本。

在[]

# Initialize mu and sigma
mu, sigma = 0, 0.1

# Drawing 5 samples in a one-dimensional array
np.random.normal(mu, sigma, 5)

Out[]

array([ 0.06790522,  0.0092956 ,  0.07063545,  0.28022021, -0.13597963])

在[]

# Drawing 10 samples in a two-dimensional array of shape (2, 5)
np.random.normal(mu, sigma, (2, 5))

out[]array([[-0.10696306, -0.0147926 , -0.07027478, 0.04399432, -0.03861839], [-0.02004485, 0.08760261, 0.18348247, -0.09351321, -0.19487115]])

7。uniform(low=0.0，high=1.0，size=None) 如果没有提供参数，则从间隔 0(包括)和 1(不包括)的均匀分布中抽取样本。换句话说，在区间内，任何得出的值都是同等可能的。

在[]

# Creating a one-dimensional array with samples drawn within [-1, 0)
np.random.uniform(-1, 0, 10)

Out[]

array([-0.7910379 , -0.64144624, -0.64691011, -0.03817127, -0.24480339,
       -0.82549031, -0.37500955, -0.88304322, -0.35196588, -0.51377252])

在[]

# Creating a two-dimensional array with samples drawn within [0, 1)
np.random.uniform(size=(5, 2))

Out[]

array([[0.43155784, 0.41360889],
       [0.81813931, 0.70115211],
       [0.40003811, 0.2114227 ],
       [0.95487774, 0.92251769],
       [0.91042434, 0.98697917]])

除了上面显示的函数，我们还可以从其他各种分布中抽取样本，如泊松分布、伽马分布、指数分布等。使用 Python NumPy。

我们现在对 Python NumPy 数组的工作有了一些了解。现在让我们来探索它们所提供的功能。与任何 Python 对象一样，

NumPy 数组也有一组丰富的属性和方法，这在很大程度上简化了数据分析过程。以下是最有用的数组属性。为了便于说明，我们将使用以前定义的数组。

1。ndim 属性显示一个数组的维数。在 n_call_vol 和 pcr 上使用这个属性，我们期望维度分别为 1 和 2。让我们检查一下。

在[]

# Checking dimensions for n_call_vol array
np_call_vol.ndim

Out[]

1

在[]

n_2d.ndim

Out[]

2

2。shape 返回数组维数的元组。它还可以通过向数组分配数组维度元组来就地重塑数组。

在[]

# Checking the shape of the one-dimensional array
n_put_vol.shape

Out[]

(5,)

在[]

# Checking shape of the two-dimensional array
n_2d.shape

Out[]

(2, 5) *# It shows 2 rows and 5 columns*

在[]

# Printing n_2d with 2 rows and 5 columns
n_2d

Out[]

array([[52.89, 45.14, 63.84, 77.1 , 74.6 ],
       [49.51, 50.45, 59.11, 80.49, 65.11]])

在[]

# Reshaping n_2d using the shape attribute
n_2d.shape = (5, 2)

# Printing reshaped array
n_2d

Out[]

array([[52.89, 45.14],
       [63.84, 77.1 ],
       [74.6 , 49.51],
       [50.45, 59.11],
       [80.49, 65.11]])

3。size 返回数组中元素的数量。

在[]

n_call_vol.size

Out[]

5

在[]

n_2d.size

Out[]

10

4。dtype 返回数组元素的数据类型。正如我们在上面了解到的，NumPy 自带了自己的数据类型，就像常规的内置数据类型一样，比如 int、float、str 等等。

在[]

n_put_vol.dtype

Out[]

dtype('float64')

在理想的数据分析过程中，我们通常有成千上万的数字需要分析。仅仅盯着这些数字不会给我们提供任何见解。相反，我们能做的是生成数据的汇总统计。在许多有用的特性中，Python NumPy 还提供了各种统计函数，可以很好地对数组进行统计。

让我们创建一个样本数组，用从均值为 5、标准差为 1.5 的正态分布中抽取的样本填充它，并计算它的各种统计数据。

在[]

# Creating a one-dimensional array with 1000 samples drawn from a normal distribution
samples = np.random.normal(5, 1.5, 1000)

# Creating a two-dimensional array with 25 samples drawn from a normal distribution
samples_2d = np.random.normal(5, 1.5, size=(5, 5))

samples_2d

Out[]

array([[5.30338102, 6.29371936, 2.74075451, 3.45505812, 7.24391809],
       [5.20554917, 5.33264245, 6.08886915, 5.06753721, 6.36235494],
       [5.86023616, 5.54254211, 5.38921487, 6.77609903, 7.79595902],
       [5.81532883, 0.76402556, 5.01475416, 5.20297957, 7.57517601],
       [5.76591337, 1.79107751, 5.03874984, 5.05631362, 2.16099478]])

5。mean(a，axis=None) 返回数组元素的平均值。默认情况下，平均值是在展平的数组上计算的，否则在指定的轴上计算。

average(a，axis=None)得出数组元素的平均值，工作方式类似于 mean()。

In[]

# Computing mean
np.mean(samples)

Out[]

5.009649198007546

In[]

np.average(samples)

Out[]

5.009649198007546

In[]

# Computing mean with axis=1 (over each row)
np.mean(samples_2d, axis=1)

Out[]

array([5.00736622, 5.61139058, 6.27281024, 4.87445283, 3.96260983])

In[]

np.average(samples_2d, axis=1)

Out[]

array([5.00736622, 5.61139058, 6.27281024, 4.87445283, 3.96260983])

6. max(a, axis=None) returns the maximum of an array or maximum along an axis.

在[]

np.max(samples)

Out[]

9.626572532562523

在[]

np.max(samples_2d, axis=1)

out[]

array([7.24391809, 6.36235494, 7.79595902, 7.57517601, 5.76591337])

7 .。median(a，axis=None) 返回沿指定轴的中值。

在[]

np.median(samples)

Out[]

5.0074934668143865

在[]

np.median(samples_2d)

Out[]

5.332642448141249

8。min(a，axis=None) 返回一个数组的最小值或沿一个轴的最小值。

在[]

np.min(samples)

Out[]

0.1551821703754115

在[]

np.min(samples_2d, axis=1)

Out[]

array([2.74075451, 5.06753721, 5.38921487, 0.76402556, 1.79107751])

9。var(a，axis=None) 返回一个数组或沿指定轴的方差。

在[]

np.var(samples)

Out[]

2.2967299389550466

在[]

np.var(samples_2d)

Out[]

2.93390175942658

在[]

np.var(samples_2d, axis=0) # Here, the variance is computed over each column of numbers

Out[]

array([0.07693981, 4.95043105, 1.26742732, 1.10560727, 4.37281009])

10。std(a，axis=None) 返回一个数组或沿指定轴的标准偏差。

在[]

np.std(samples)

Out[]

1.5154965981337756

在[]

np.std(samples_2d)

Out[]

1.7128636137844075

11。sum(a，axis=None) 返回数组元素的和。

在[]

# Recalling the array n_put_vol
n_put_vol

Out[]

array([52.89, 45.14, 63.84, 77.1 , 74.6 ])

在[]

# Computing sum of all elements within n_put_vol
np.sum(n_put_vol)

Out[]

313.57

在[]

# Computing sum of all array over each row
np.sum(samples_2d, axis=1)

Out[] array([25.03683109, 28.05695291, 31.36405118, 24.37226413, 19.81304913])

12。cumsum(a，axis=None) 返回给定坐标轴上元素的累积和。
中的

np.cumsum(n_put_vol)

Out[]

array([ 52.89,  98.03, 161.87, 238.97, 313.57])

上面讨论的方法也可以直接调用 NumPy 对象，如 samples、n_put_vol、samples_2d 等。而不是用 np。格式如下所示。

两种情况下输出都是一样的。

在[]

# Using np. format to compute the sum
np.sum(samples)

Out[]

5009.649198007546

在[]

# Calling sum() directly on a NumPy object
samples.sum()

Out[]

5009.649198007546

Python NumPy 为它创建的数组对象定义了一个名为 ndarray 的新数据类型。这也意味着各种运算符，如算术运算符、逻辑运算符、布尔运算符等。以我们目前所见的独特方式工作。

有一种灵活而有用的数组操作技术， Python NumPy 提供了这种技术，可以使用广播对其数据结构进行操作。

术语 broadcasting 描述了 Python NumPy 在算术运算过程中如何处理不同形状的数组(有一定的约束)。较小的阵列在较大的阵列中传播，因此它们具有兼容的形状。它还提供了一种向量化数组操作的方法。

Python NumPy 操作通常是在一个元素接一个元素的基础上对数组对进行的。在最简单的情况下，这两个数组必须具有与下例完全相同的形状。

在[]

a = np.array([1, 2, 3])

b = np.array([3, 3, 3])

a * b

Out[]

array([3, 6, 9])

当数组的形状满足某些约束时，Python NumPy 的广播规则放松了这种约束。

最简单的广播例子发生在一个数组和一个标量值在运算中组合在一起时，如下图所示:

在[]

a = np.array([1, 2, 3])

b = 3

a * b

Out[]

array([3, 6, 9])

结果相当于前一个例子，其中 b 是一个数组。我们可以把上面例子中的标量 b 在算术运算过程中拉伸成一个与 a 形状相同的数组

b 中的新元素只是原始标量的副本。这里，拉伸类比只是概念性的。Python NumPy 足够聪明，可以使用原始标量值，而无需实际制作副本，因此广播操作尽可能节省内存和提高计算效率。

最后一个例子中的代码效率更高，因为广播在乘法期间移动的内存比它上面定义的对应代码要少。

除了高效的数字处理能力，Python NumPy 还提供了多种数组操作方法，从而证明了它的通用性。

我们在这里讨论其中的一些。

1。exp(*args) 返回输入数组中所有元素的指数。这些数字将被提高到 e，也称为欧拉数。

在[]

# Computing exponentials for the array 'a'
np.exp(a)

Out[]

array([ 2.71828183,  7.3890561 , 20.08553692])

2。sqrt(*args) 按元素返回数组的正平方根。

在[]

# Computing square roots of a given array
np.sqrt([1, 4, 9, 16, 25])

Out[]

array([1., 2., 3., 4., 5.])

3。reshape(new_shape) 给一个数组一个新的形状，而不改变它的数据。

在[]

# Creating a one-dimensional array with 12 elements
res = np.arange(12)

res

Out[]

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

在[]

# Reshaping the 'res' array to 2-dimensional array
np.reshape(res, (3, 4))

Out[]

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

在[]

# Reshaping the dimensions from (3, 4) to (2, 6)
np.reshape(res, (2, 6))

Out[]

array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11]])

4。resize(a，new_shape) 返回指定形状的新数组。如果新数组比原始数组大，那么新数组中会填充。

在[]

# Creating a one-dimensional array
demo = np.arange(4)

demo

Out[]

array([0, 1, 2, 3])

在[]

# Resizing a 'demo' array to (2, 2)
np.resize(demo, (2, 2))

Out[]

array([[0, 1],
       [2, 3]])

在[]

# Resizing a 'demo' greater than its size.
np.resize(demo, (4, 2))

out[]array([[0, 1], [2, 3], [0, 1], [2, 3]])

5。round(a，decimals=0) 将数组舍入到给定的小数位数。如果没有给出小数，元素将被四舍五入为整数。

在[]

# Creating a one-dimensional array
a = np.random.rand(5)

# Printing array
a

Out[]

array([0.71056952, 0.58306487, 0.13270092, 0.38583513, 0.7912277 ])

在[]

# Rounding to 0 decimals
a.round()

Out[]

array([1., 1., 0., 0., 1.])

在[]

# Rounding to 0 decimals using the np.round syntax
np.round(a)

Out[]

array([1., 1., 0., 0., 1.])

在[]

# Rounding to 2 decimals
a.round(2)

Out[]

array([0.71, 0.58, 0.13, 0.39, 0.79])

在[]

# Rounding to 3 decimals using the np.round syntax
np.round(a, 3)

Out[]

array([0.711, 0.583, 0.133, 0.386, 0.791])

6。sort(a，kind='quicksort') 返回一个数组的排序副本。使用的默认排序算法是快速排序。其他可用的选项有 mergesort 和 heapsort。

在[]

np.sort(n_put_vol)

Out[]

array([45.14, 52.89, 63.84, 74.6 , 77.1 ])

在[]

np.sort(samples_2d)

Out[]

array([[2.74075451, 3.45505812, 5.30338102, 6.29371936, 7.24391809],
       [5.06753721, 5.20554917, 5.33264245, 6.08886915, 6.36235494],
       [5.38921487, 5.54254211, 5.86023616, 6.77609903, 7.79595902],
       [0.76402556, 5.01475416, 5.20297957, 5.81532883, 7.57517601],
       [1.79107751, 2.16099478, 5.03874984, 5.05631362, 5.76591337]])

7。vstack(tup) 将通过 tup 提供的数组垂直按顺序(按行)堆叠。

  • hstack(tup) 将通过 tup 提供的数组按顺序水平堆叠(按列)。
  • column_stack(tup) 将一维数组作为列堆叠成二维数组。它接受一系列一维数组，并将它们按列堆叠起来，形成一个二维数组。

在[]

# Creating sample arrays
a = np.array([1, 2, 3])

b = np.array([4, 5, 6])

c = np.array([7, 8, 9])

# Stacking arrays vertically
np.vstack((a, b, c))

Out[]

array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

在[]

# Stacking arrays horizontally
np.hstack((a, b, c))

Out[]

array([1, 2, 3, 4, 5, 6, 7, 8, 9])

在[]

# Stacking two arrays together
np.column_stack((a, b))

Out[]

array([[1, 4],
       [2, 5],
       [3, 6]])

在[]

# Stacking three arrays together
np.column_stack((a, b, c))

Out[]

array([[1, 4, 7],
       [2, 5, 8],
       [3, 6, 9]])

8。transpose() 改变数组的维数。

在[]

# Creating a two-dimensional array with shape (2, 4)
a = np.arange(8).reshape(2, 4)

# Printing it
a

Out[]

array([[0, 1, 2, 3],
       [4, 5, 6, 7]])

在[]

# Transposing the array
a.transpose()

Out[]

array([[0, 4],
       [1, 5],
       [2, 6],
       [3, 7]])

NumPy 是一个优秀的库，可以高效地处理数字，并且易于使用。它与 Python 及其语法无缝集成。在这个属性之后，Python NumPy 提供了非常类似于列表的子集化和迭代技术。

我们可以用方括号对 NumPy 数组进行子集化，用 Python 内置的构造进行迭代，用其他内置的方法进行切片。

索引和子集化

NumPy 数组遵循类似于 Python 列表的索引结构。Index 从 0 开始，数组中的每个元素都与一个唯一的索引相关联。下表显示了一维数组的 NumPy 索引。

index 0 1 2 3 4
NP . array 52 88 41 63 94

The index structure for a two-dimensional array with a shape of (3, 3) is shown below.

索引 Zero one Two
Zero a b c
one d e f
Two g h 我

描述上述结构的两个数组 arr_1d 和 arr_2d 已在下面创建:

在[]

# Creating one-dimensional array
arr_1d = np.array([52, 88, 41, 63, 94])

# Creating two-dimensional array
arr_2d = np.array([['a', 'b', 'c'],
    ...:                    ['d', 'e', 'f'],
    ...:                    ['g', 'h', 'i']])

我们使用方括号[]来划分 NumPy 数组中每个元素的子集。让我们使用索引对上面创建的数组进行子集化。

在[]

# Slicing the element at index 0
arr_1d[0]

Out[]

52

在[]

# Slicing the last element using negative index
arr_1d[-1]

Out[]

94

在[]

# Slicing elements from position 2 (inclusive) to 5 (exclusive)
arr_1d[2:5]

Out[]

array([41, 63, 94])

在上面的例子中，我们对一维数组进行了切片。类似地，方括号也允许使用语法[r，c]进行二维切片，其中 r 是一行，c 是一列。

在[]

# Slicing the element at position (0, 1)
arr_2d[0, 1]

Out[]

'b'

在[]

# Slicing the element at position (1, 2)
arr_2d[1, 2]

Out[]

'f'

在[]

# Slicing the element at position (2, 0)
arr_2d[2, 0]

Out[]

'g'

在[]

# Slicing the first row
arr_2d[0, ]

Out[]

array(['a', 'b', 'c'], dtype='<U1')

在[]

# Slicing the last column
arr_2d[:, 2]

Out[]

array(['c', 'f', 'i'], dtype='<U1')

请注意上一个示例中的语法，我们对最后一列进行了切片。

“:”已作为输入提供，表示所有元素，然后过滤最后一列。仅使用“:”将返回数组中的所有元素。

在[]

arr_2d[:]

Out[]

array([['a', 'b', 'c'],
       ['d', 'e', 'f'],
       ['g', 'h', 'i']], dtype='<U1')

布尔索引

NumPy 数组可以用其他数组(或列表)进行索引。用于索引其他数组的数组称为索引数组。大多数情况下，它是一个简单的数组，用来作为其他数组的子集。

索引数组的使用范围从简单、直接的情况到复杂、难以理解的情况。当使用另一个数组对一个数组进行索引时，返回的是原始数据的副本，而不是像获取切片那样的视图。

来说明:

在[]

# Creating an array
arr = np.arange(1, 10)

# Printing the array
arr

Out[]

array([1, 2, 3, 4, 5, 6, 7, 8, 9])

在[]

# Subsetting the array `arr` using an anonymous array
arr[np.array([2, 5, 5, 1])]

Out[]

array([3, 6, 6, 2])

在上面的例子中，我们创建了一个有十个元素的数组 arr。然后，我们尝试使用匿名索引数组对其进行子集化。

由值 2、5、5、1 组成的索引数组对应创建一个长度为 4 的数组，即与长度索引数组相同。

索引数组中的值作为子集的索引(在上面给出的操作中),它只是从数组中返回相应的值。

扩展这个概念，一个数组可以自己索引。使用逻辑运算符，可以根据需要过滤 NumPy 数组。考虑一个场景，我们需要过滤大于某个阈值的数组值。

如下图:

在[]

# Creating an random array with 20 values
rand_arr = np.random.randint(1, 50, 20)

# Printing the array
rand_arr

Out[]

array([14, 25, 39, 18, 40, 10, 33, 36, 29, 25, 27,  4, 28, 43, 43, 19, 30,
       29, 47, 41])

在[]

# Filtering the array values which are greater than 30
rand_arr[rand_arr > 30]

Out[]

array([39, 40, 33, 36, 43, 43, 47, 41])

这里，我们创建一个名为 rand_arr 的数组，包含 20 个随机值。然后，我们尝试使用逻辑运算符>，用大于 30 的值对其进行子集划分。当使用逻辑运算符

对数组进行切片时，Python NumPy 会生成一个包含真值和假值的匿名数组，然后使用该数组对数组进行子集化。为了说明这一点，让我们执行用于 rand_arr 子集的代码，即写在方括号内的代码。

在[]

filter_ = rand_arr > 30

filter_

Out[]

array([False, False,  True, False,  True, False,  True,  True, False,
       False, False, False, False,  True,  True, False, False, False,
        True,  True])

它返回一个只有 True 和 False 值的布尔数组。在这里，只要逻辑条件成立，就会出现 True。Python NumPy 使用这个输出的数组作为原始数组的子集，并且只返回那些为真的值。除了这种方法，Python NumPy 还提供了一个 where 方法，使用它我们可以获得相同的过滤输出。我们在 where 条件中传递一个逻辑条件，它将返回一个数组，其中包含条件为真的所有值。

在下面的例子中，我们使用 where 条件从 rand_arr 中过滤出所有大于 30 的值:

在[]

# Filtering an array using np.where method
rand_arr[np.where(rand_arr > 30)]

Out[]

array([39, 40, 33, 36, 43, 43, 47, 41])

我们通过执行 rand_arr[rand_arr > 30]和 rand _ arr[NP . where(rand _ arr > 30)]得到了相同的结果。然而，Python NumPy 提供的 where 方法并不过滤值。相反，它可以用于更通用的场景。

下面给出的是官方语法:

np.where[condition[, x, y]]

它根据条件从 x 或 y 返回元素。作为这些参数，x 和 y 是可选的，如果给定为真，则条件为 x，否则为 y 或布尔值为假。下面我们创建一个包含 20 个元素的数组高度，高度范围从 150 到 160，看看 where 方法的各种用法。

在[]

# Creating an array heights
heights = np.random.uniform(150, 160, size=20)

heights

Out[]

array([153.69911134, 154.12173942, 150.35772942, 151.53160722,
       153.27900307, 154.42448961, 153.25276742, 151.08520803,
       154.13922276, 159.71336708, 151.45302507, 155.01280829,
       156.9504274 , 154.40626961, 155.46637317, 156.36825413,
       151.5096344 , 156.75707004, 151.14597394, 153.03848597])

用法 1:不带 x 和 y 参数
如下例所示，使用不带可选参数的 where 方法将返回条件为真的原始数组的索引值。

在[]

np.where(heights > 153)

Out[]

(array([ 0,  1,  4,  5,  6,  8,  9, 11, 12, 13, 14, 15, 17, 19],
       dtype=int64),)

上述代码返回高度数组的索引值，其中值大于 153。这个场景与我们在上面看到的随机数组 rand_arr 非常相似，我们试图过滤大于 30 的值。

在这里，输出仅仅是指标值。如果我们想要原始值，我们需要使用我们获得的输出对 heights 数组进行子集化。

用法 2:x 为真，y 为假
有了这些可选参数，将根据条件返回其中一个参数。如下例所示:

在[]

np.where(heights > 153, True, False)

Out[]

array([True, True, False,  False, True, True, True, False, True,
        True, False, True, True, True, True, True, False, True,
       False, True])

用法 2 的输出为 heights 数组中的所有元素提供 true 或 False，而用法 1 只返回条件为 True 的元素的索引值。

可选参数也可以是类似数组的元素，而不是标量或静态值，如 True 或 False。

用法 3:x 和 y 是数组
现在我们已经很好地理解了该方法的工作原理，猜测输出是相当容易的。根据第一个参数中的条件，输出将包含来自 x 数组或 y 数组的值。
例如:

在[]

# Creating an array 'x_array'
x_array = np.arange(11, 31, 1)

x_array

Out[]

array([11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
       28, 29, 30])

在[]

# Creating an array 'y_array'
y_array = np.arange(111, 131, 1)

y_array

Out[]

array([111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
       124, 125, 126, 127, 128, 129, 130])

在[]

np.where(heights > 153, x_array, y_array)

Out[]

array([ 11,  12, 113, 114,  15,  16,  17, 118,  19,  20, 121,  22,  23,
        24,  25,  26, 127,  28, 129,  30])

正如所料，当 heights 数组中的值大于 153 时，上述代码片段的输出包含来自数组 x_array 的值，否则，将输出来自 y_array 的值。理解了 Python NumPy 库提供的 where 方法的工作原理后，现在让我们看看它在回溯测试策略中是如何有用的。考虑一个场景，我们有生成交易信号所需的所有数据。

对于这个假设的例子，我们拥有的数据是一只股票 20 个周期的收盘价及其平均价格。

在[]

# Hypothetical close prices for 20 periods
close_price = np.random.randint(132, 140, 20)

# Printing close_price
close_price

Out[]

array([137, 138, 133, 132, 134, 139, 132, 138, 137, 135, 136, 134, 134,
       139, 135, 133, 136, 139, 132, 134])

我们将根据给我们的买入条件产生交易信号。即当收盘价高于平均价 135.45 时，我们做多或买入股票。使用 where 方法可以很容易地计算出来，如下所示:

在[]

# Average close price
avg_price = 135.45

# Computing trading signals with 1 being 'buy' and 0 represents 'no signal'
signals = np.where(close_price > avg_price, 1, 0)

# Printing signals
signals

Out[]

array([1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0])

信号数组包含交易信号，其中 1 代表买入，0 代表没有交易信号。

迭代数组

NumPy 数组是 Python 中的可迭代对象，这意味着我们可以像处理任何其他可迭代对象一样，使用 iter()和 next()方法直接迭代它们。这也意味着我们可以使用内置的循环结构来迭代它们。

下面的例子展示了使用 for 循环迭代 NumPy 数组。

在[]

# Looping over a one-dimensional array
for element in arr_1d:
     print(element)

Out[]

52
88
41
63
94

在一维数组上循环简单而直接。但是，如果我们要用 arr_2d 执行 for 循环，它将遍历所有行并提供输出。

如下例所示。

在[]

for element in arr_2d:
  print(element)

Out[]

['a' 'b' 'c']
['d' 'e' 'f']
['g' 'h' 'i']

为了迭代二维数组，我们需要考虑两个轴。可以在嵌套格式中使用单独的 for 循环来遍历每个元素，如下所示:

在[]

for element in arr_2d:
 for e in element:
       print(e)

Out[]

a
b
c
d
e
f
g
h
i

我们得到的输出也可以使用 Python NumPy 的 nditer()方法来实现，它的工作与维度无关。

在[]

for element in np.nditer(arr_2d):
   print(element)

Out[]

a
b
c
d
e
f
g
h
i

这就结束了 Python NumPy 模块的旅程。上面提供的例子只描述了 Python NumPy 功能的最小集合。虽然不全面，但它应该让我们对什么是 NumPy 以及为什么我们应该使用它有一个很好的感觉。

  • NumPy 库用于在 Python 中执行科学计算。
  • 它不是 Python 标准库的一部分，需要在程序中使用之前明确安装。
  • 它允许创建 ndarray 类型的 n 维数组。
  • NumPy 数组只能保存单一数据类型的元素。
  • 可以使用任何顺序数据结构(如列表或元组)或内置的 NumPy 函数来创建它们。
  • NumPy 库的随机模块允许从各种数据分布中生成样本。
  • NumPy 支持使用广播功能的逐元素操作。
  • 与列表类似，NumPy 数组也可以使用方括号[]切片，并从 0 开始索引。
  • 也可以根据逻辑条件对 NumPy 数组进行切片。得到的数组将是一个布尔值 True 或 False 的数组，其他数组将基于该数组进行切片或过滤。这就是所谓的布尔索引。

重申一下，这篇文章是从 Python 基础手册中摘录的，它是为这两者而创作的；刚开始使用 Python 的新手，以及有成就的交易者，他们可以在编写策略时使用它作为方便的参考。

请在下面的评论中告诉我们你是否喜欢这篇文章以及其他反馈。

免责声明:股票市场的所有投资和交易都涉及风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。T11】

Python 熊猫教程:安装、系列和数据框架

原文：https://blog.quantinsti.com/python-pandas-tutorial/

杰伊·帕尔马

Pandas 是一个处理顺序数据和表格数据的 Python 库。它包括许多工具，以方便有效的方式管理、分析和操作数据。我们可以认为它的数据结构类似于数据库表或电子表格。

Pandas 构建在 Numpy 库之上，有两个主要的数据结构，即。系列(一维)和数据框架(二维)。它可以处理同构和异构数据，其众多功能包括:

  • ETL 工具(提取、转换和加载工具)
  • 处理缺失数据(NaN)
  • 处理数据文件(csv、xls、db、hdf5 等。)
  • 时间序列操作工具

在 Python 生态系统中，Pandas 是检索、操作、分析和转换金融数据的最佳选择。

在这个 Python 熊猫教程中，我们将学习 Python 熊猫模块的基础知识，并理解一些代码。这篇博客文章是从 Python 基础手册中摘录的，其创建的简单目的是让读者理解 Python 语言的美丽和简单。

本文的内容包括:

安装 Python 熊猫

在 Python Pandas 教程的这一部分，我们将开始浏览官方文档，其中有关于安装 Pandas 的详细解释。我们总结如下。

和皮普一起

最简单的安装熊猫的方法是从 PyPI。

在终端窗口中，运行以下命令。

pip install pandas

在您的代码中，您可以使用转义符'！从你的 Python 控制台直接安装 pandas。

!pip install pandas

Pip 是管理 Python 包的有用工具，值得花些时间更好地了解它。

pip help

对于康达环境

对于喜欢在每个项目中使用 Python 环境的高级用户，您可以创建一个新环境并安装 pandas，如下所示。

conda create -n EPAT python
source activate EPAT
conda install pandas

测试熊猫装置

为了检查安装，Pandas 附带了一个测试套件来测试几乎所有的代码库，并验证一切正常。

import pandas as pd
pd.test()

Python 熊猫解决什么问题？

在 Python 熊猫教程的这一节，我们将了解 Python 熊猫的用法。

Python Pandas 处理同质数据系列(一维)和异质表格数据系列(二维)。它包括许多处理这些数据类型的工具，例如:

  • 索引和标签。
  • 元素搜索。
  • 元素的插入、删除和修改。
  • 应用集合技术，如分组、连接、选择等。
  • 数据处理和清理。
  • 使用时间序列。
  • 进行统计计算
  • 绘制图形
  • 多种数据文件格式的连接器，如 csv、xlsx、hdf5 等。

熊猫纪录片:与熊猫共度 10 分钟

蟒蛇熊猫系列

我们将在 Python 熊猫教程中学习的第一个数据结构是 Series。

Python Pandas 系列是同构的一维对象，也就是说，所有数据都是同一类型的，并且隐式地用一个索引来标记。

例如，我们可以有一系列整数、实数、字符、字符串、字典等。我们可以方便地操纵这些系列执行操作，如添加、删除、排序、连接、过滤、矢量化操作、统计分析、绘图等。

让我们看一些如何创建和操作 Python 熊猫系列的例子:

  • 我们将从创建一个空的 Python 熊猫系列开始:
import pandas as pd
s = pd.Series()
print(s)

Out[]: 

Series([], dtype: float64)
  • 让我们创建一个 Python 熊猫系列的整数:
import pandas as pd
s = pd.Series([1, 2, 3, 4, 5, 6, 7])
print(s)

Out[]:
        0    1
        1    2
        2    3
        3    4
        4    5
        5    6
        6    7
        dtype: int64
  • 让我们创建一个 Python 熊猫系列角色:
import pandas as pd
s = pd.Series(['a', 'b', 'c', 'd', 'e'])
print(s)

Out[]: 
        0    1
        1    2
        2    3
        3    4
        4    5
        5    6
        6    7
        dtype: int64
  • 让我们创建一个随机的 Python 熊猫系列浮点数:
import pandas as pd
import numpy as np
s = pd.Series(np.random.randn(5))
print(s)

Out[]:  
 0    0.383567
        1    0.869761
        2    1.100957
        3   -0.259689
        4    0.704537
        dtype: float64

在我们在 Python Pandas 教程中看到的所有例子中，我们都允许默认显示索引标签(没有显式编程)。它从 0 开始，我们可以这样检查索引:

In[]: 

s.index

Out[]: 

RangeIndex(start=0, stop=5, step=1)

但是我们也可以指定我们需要的索引，例如:

In[]: 

s = pd.Series(np.random.randn(5), index=['a', 'b', 'c', 'd', 'e'])

Out[]:
      a    1.392051
      b    0.515690
      c   -0.432243
      d   -0.803225
      e    0.832119
      dtype: float64
  • 让我们根据字典创建一个 Python 熊猫系列:
import pandas as pd
dictionary = {'a' : 1, 'b' : 2, 'c' : 3, 'd': 4, 'e': 5}
s = pd.Series(dictionary)
print(s)

Out[]:

        a    1
        b    2
        c    3
        d    4
        e    5
        dtype: int64

在这种情况下，除非我们指定任何其他索引，否则 Python Pandas 系列是使用字典键作为索引创建的。

Python 熊猫系列的简单操作

当我们有一个 Python 熊猫系列时，我们可以对它执行几个简单的操作。

例如，在 Python 熊猫教程的这一部分，让我们创建两个系列。一个来自字典，另一个来自整数数组:

In[]: 
 import pandas as pd
      dictionary = {'a' : 1, 'b' : 2, 'c' : 3, 'd': 4, 'e': 5}
      s1 = pd.Series(dictionary)

      array = [1, 2, 3, 4, 5]
      s2 = pd.Series(array)

Out[]:  
 a    1
        b    2
        c    3
        d    4
        e    5
        dtype: int64

        0    1
        1    2
        2    3
        3    4
        4    5
        dtype: int64

我们可以执行类似于 Numpy 数组的操作:

  • 通过索引从 Python Pandas 系列中选择一个项目:
In[]: 
s1[0] # Select the first element

Out[]: 
1

In[]: 
s1['a'] 

Out[]: 
1

In[]: 
s2[0] 

Out[]: 
1
  • 通过索引从 Python Pandas 系列中选择几个项目:
In[]: 
s1[[1,4]]

Out[]:
        b    2
        e    5
        dtype: int64

In[]: s1[['b', 'e']]

Out[]:  
 b    2
        e    5
        dtype: int64

In[]: 
s2[[1,4]]

Out[]:  
 b    2
        e    5
        dtype: int64
  • 从一个元素开始获取 Python 熊猫系列:
In[]: 
s1[2:]

Out[]:  
 c    3
        d    4
        e    5
        dtype: int64

In[]: 
s2[2:]

Out[]:  
 2    3
        3    4
        4    5
        dtype: int64
  • 让 Python 熊猫系列达到一个元素:
In[]: 
s1[:2]

Out[]:  
 c    3
        d    4
        e    5
        dtype: int64

In[]: 
s2[:2]

Out[]:  
 2    3
        3    4
        4    5
        dtype: int64

我们可以像字典一样执行操作:

  • 分配一个值:
In[]: 
 s1[1] = 99
      s1['a'] = 99

Out[]:  
 a     1
        b    99
        c     3
        d     4
        e     5
        dtype: int64

In[]: 
s2[1] = 99
print(s2)

Out[]:  
 0     1
        1    99
        2     3
        3     4
        4     5
        dtype: int64
  • 通过索引获取值(如字典键):
In[]: 
s.get('b')

Out[]: 
2

下面是一些强大的矢量化运算，可以让我们快速执行计算，例如:

  • 加、减、乘、除、幂，以及几乎任何接受 NumPy 数组的 NumPy 函数。
s1 + 2
s1 - 2
s1 * 2
s1 / 2
s1 ** 2
np.exp(s1)
  • 我们可以对两个 Python 熊猫系列执行相同的操作，尽管它们必须对齐，也就是说，要有相同的索引，在其他情况下，执行联合操作。
In[]: 
s1 + s1 # The indices are aligned

Out[]:  
 a     2
        b     4
        c     6
        d     8
        e    10
        dtype: int64

In[]: 
s1 + s2 # The indices are unaligned

Out[]:  
 a   NaN
        b   NaN
        c   NaN
        d   NaN
        e   NaN
        0   NaN
        1   NaN
        2   NaN
        3   NaN
        4   NaN
        dtype: float64

蟒蛇熊猫数据框

我们将要看到的 Python Pandas 中的第二个数据结构是 DataFrame。

Python Pandas DataFrame 是一个异构的二维对象，也就是说，每一列中的数据都是相同的类型，但每一列的数据类型可能不同，并且用索引隐式或显式地标记。

我们可以把 Python Pandas DataFrame 想象成一个数据库表，我们在其中存储异构数据。例如，Python Pandas 数据框架有一列用于名，另一列用于姓，第三列用于电话号码，或者 Python Pandas 数据框架有多列用于存储开盘价、收盘价、最高价、最低价、成交量等。

索引可以是隐式的，从零开始，或者我们可以自己指定它，甚至还可以使用日期和时间作为索引。

让我们看一些如何创建和操作 Python 熊猫数据框架的例子。

  • 创建一个空的 Python 熊猫数据框架:
In[]: 
 import pandas as pd
      s = pd.DataFrame()
      print(s)

Out[]:  
 Empty DataFrame
        Columns: []
        Index: []
  • 创建空结构 Python 熊猫数据帧:
In[]: 
 import pandas as pd
      s = pd.DataFrame(columns=['A','B','C','D','E'])
      print(s)

Out[]:  
 Empty DataFrame
        Columns: [A, B, C, D, E]
        Index: []

In[]: 
 import pandas as pd
      s = pd.DataFrame(columns=['A','B','C','D','E'], index=range(1, 6))
      print(s)

Out[]:
             A    B    C    D    E
        1  NaN  NaN  NaN  NaN  NaN
        2  NaN  NaN  NaN  NaN  NaN
        3  NaN  NaN  NaN  NaN  NaN
        4  NaN  NaN  NaN  NaN  NaN
        5  NaN  NaN  NaN  NaN  NaN
  • 通过 NumPy 数组创建 Python Pandas 数据帧:
In[]: 
 array =  {'A' : [1, 2, 3, 4],
                'B' : [4, 3, 2, 1]}

      pd.DataFrame(array)

Out[]: 
        A   B
      0 1   4
      1 2   3
      2 3   2
      3 4   1
  • 创建 Python Pandas 数据帧，传递 NumPy 数组，日期时间索引为:
In[]: 
 import pandas as pd
      array =  {'A' : [1, 2, 3, 4],'B' : [4, 3, 2, 1]}
      index = pd.DatetimeIndex(['2018-12-01', '2018-12-02','2018-12-03', '2018-12-04'])
      pd.DataFrame(array, index=index)

Out[]:
                 A B
    2018-12-01  1   4
    2018-12-02  2   3
    2018-12-03  3   2
    2018-12-04  4   1
  • 创建 Python 熊猫数据帧传递字典:
In[]: 
 import pandas as pd
      dictionary = {'a' : 1, 'b' : 2, 'c' : 3, 'd': 4, 'e': 5}
      pd.DataFrame([dictionary])

Out[]:
        a   b   c   d   e
      0 1   2   3   4   5
  • 查看 Python 熊猫数据框架:我们可以使用一些方法来探索熊猫数据框架:

首先，我们创建一个 Python 熊猫数据框架来使用它。

In[]: 
 import pandas as pd
      pd.DataFrame({'A' : np.random.randn(10), 'B' : np.random.randn(10), 'C' : np.random.randn(10)})

Out[]:
            A         B           C
    0   0.164358    1.689183    1.745963
    1   -1.830385   0.035618    0.047832
    2   1.304339    2.236809    0.920484
    3   0.365616    1.877610    -0.287531
    4   -0.741372   -1.443922   -1.566839
    5   -0.119836   -1.249112   -0.134560
    6   -0.848425   -0.569149   -1.222911
    7   -1.172688   0.515443    1.492492
    8   0.765836    0.307303    0.788815
    9   0.761520    -0.409206   1.298350
  • 获取前三行:
In[]: 
 import pandas as pd
      df=pd.DataFrame({'A' : np.random.randn(10), 'B' : np.random.randn(10), 'C' : np.random.randn(10)})

      df.head(3)

Out[]:
            A         B           C
    0   0.164358    1.689183    1.745963
    1   -1.830385   0.035618    0.047832
    2   1.304339    2.236809    0.920484
  • 获取最后三行:
In[]: 
 import pandas as pd
      df=pd.DataFrame({'A' : np.random.randn(10), 'B' : np.random.randn(10), 'C' : np.random.randn(10)})

      df.tail(3)

Out[]:
           A         B           C
    7   -1.172688   0.515443    1.492492
    8   0.765836    0.307303    0.788815
    9   0.761520    -0.409206   1.298350
  • 获取 Python 熊猫数据框架的索引:
In[]: 
 import pandas as pd
      df=pd.DataFrame({'A' : np.random.randn(10), 'B' : np.random.randn(10), 'C' : np.random.randn(10)})

      df.index

Out[]: 
RangeIndex(start=0, stop=10, step=1)
  • 获取 Python 熊猫数据框架的列:
In[]: 
 import pandas as pd
      df=pd.DataFrame({'A' : np.random.randn(10), 'B' : np.random.randn(10), 'C' : np.random.randn(10)})

      df.columns

Out[]: 
Index(['A', 'B', 'C'], dtype='object')
  • 获取 Python 熊猫数据帧的值:
In[]: 
 import pandas as pd
      df=pd.DataFrame({'A' : np.random.randn(10), 'B' : np.random.randn(10), 'C' : np.random.randn(10)})

      df.values

Out[]: 
array([[ 0.6612966 , -0.60985049,  1.11955054],
       [-0.74105636,  1.42532491, -0.74883362],
       [ 0.10406892,  0.5511436 ,  2.63730671],
       [-0.73027121, -0.11088373, -0.19143175],
       [ 0.11676573,  0.27582786, -0.38271609],
       [ 0.51073858, -0.3313141 ,  0.20516165],
       [ 0.23917755,  0.55362   , -0.62717194],
       [ 0.25565784, -1.4960713 ,  0.58886377],
       [ 1.20284041,  0.21173483,  2.0331718 ],
       [ 0.62247283,  2.18407105,  0.02431867]])

在 Python Pandas 中导入数据

Python Pandas DataFrame 能够读取几种数据格式，一些最常用的是:CSV、JSON、Excel、HDF5、SQL 等。

CSV 到数据帧

最有用的功能之一是read_csv,它允许我们读取几乎任何格式的 csv 文件，并将其加载到我们的 Python Pandas 数据框架中进行处理。让我们看看如何处理 csv 文件:

import pandas as pd
df=pd.read_csv('Filename.csv')
type(df)

Out[]: 
pandas.core.frame.DataFrame

这个简单的操作将 csv 文件加载到 Python Pandas 数据帧中，之后我们就可以像前面看到的那样研究它了。

定制熊猫进口

有时 csv 文件的格式带有特定的分隔符，或者我们需要特定的列或行。在 Python 熊猫教程的这一部分，我们现在将看到一些处理这种情况的方法。

在本例中，我们希望加载一个以空格作为分隔符的 csv 文件:

import pandas as pd
df=pd.read_csv('Filename.csv', sep=' ')

在本例中，我们希望加载 0 和 5 列以及前 100 行:

import pandas as pd
df=pd.read_csv('Filename.csv', usecols=[0,1,2,3,4,5], nrows=100)

可以定制标题、转换列名或行名，以及执行许多其他操作。

查看 Pandas 文档中的 IO 工具。

从 Excel 文件导入工作表

与我们处理 csv 文件的方式相同，我们可以使用read_excel函数处理 Excel 文件，让我们看一些例子:

在本例中，我们希望从 Excel 文件中加载工作表 1:

import pandas as pd
df=pd.read_excel('Filename.xls', sheet_name='Sheet1')

这个简单的操作将工作表 1 从 Excel 文件加载到 Pandas 数据框架中。

索引和子集

一旦我们准备好 Python Pandas 数据框架，独立于我们的数据源(csv、Excel、hdf5 等)。)我们可以使用它，就像它是一个数据库表一样，选择我们感兴趣的元素。我们将使用一些例子来说明如何索引和提取数据子集。

让我们从加载一个包含市场工具详细信息的 csv 文件开始。

In[]: 
 import pandas as pd
      df=pd.read_csv('MSFT.csv' , usecols=[0,1,2,3,4,5])
      df.head()
      df.shape

Out[]:
          Date        Open  High     Low    Close   Volume
    0   2008-12-29  19.1500 19.21   18.64   18.96   58512800.0
    1   2008-12-30  19.0100 19.49   19.00   19.34   43224100.0
    2   2008-12-31  19.3100 19.68   19.27   19.44   46419000.0
    3   2009-01-02  19.5328 20.40   19.37   20.33   50084000.0
    4   2009-01-05  20.2000 20.67   20.06   20.52   61475200.0

    (1000, 6)

这里，我们已经读取了一个 csv 文件，其中我们只需要日期、开盘、收盘、高、低和成交量(前 6 列)等列，我们检查了具有 1000 行和 6 列的数据帧的形式。

选择单个列

在前面的代码中，我们直接从 csv 文件中读取了前 6 列。这是我们应用的过滤器，因为我们只对那些列感兴趣。

我们可以对 Python Pandas 数据帧本身应用选择过滤器，以选择一列进行处理。例如，我们可能需要Close列:

In[]: 
close=df['Close']
close.head()

Out[]:
        Close
    0   18.96   
    1   19.34   
    2   19.44   
    3   20.33   
    4   20.52

选择多列

我们也可以选择多个列:

In[]: 
closevol=df[['Close', 'Volume']]
closevol.head()

Out[]:
        Close  Volume
    0   18.96   58512800.0
    1   19.34   43224100.0
    2   19.44   46419000.0
    3   20.33   50084000.0
    4   20.52   61475200.0

通过[]选择行。

我们可以通过索引选择一组行:

In[]: 
 import pandas as pd
      df=pd.read_csv('TSLA.csv' )

      df[100:110]

Out[]:

|
| 日期 | 打开 | 高的 | 低的 | 关闭 | 卷 | 除息 | 分流比 | adopen | 和高 | AdjLow | 接近的 | AdjVolume | 名字 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| One hundred | 2017-10-30 | Three hundred and nineteen point one eight | 323.7800 | Three hundred and seventeen point two five | Three hundred and twenty point zero eight | Four million two hundred and thirty-six thousand and twenty-nine | Zero | One | Three hundred and nineteen point one eight | 323.7800 | Three hundred and seventeen point two five | Three hundred and twenty point zero eight | Four million two hundred and thirty-six thousand and twenty-nine | TSLA |
| One hundred and one | 2017-10-27 | Three hundred and nineteen point seven five | 324.5900 | Three hundred and sixteen point six six | Three hundred and twenty point eight seven | Six million nine hundred and forty-two thousand four hundred and ninety-three | Zero | One | Three hundred and nineteen point seven five | 324.5900 | Three hundred and sixteen point six six | Three hundred and twenty point eight seven | Six million nine hundred and forty-two thousand four hundred and ninety-three | TSLA |
| One hundred and two | 2017-10-26 | Three hundred and twenty-seven point seven eight | 330.2300 | Three hundred and twenty-three point two | Three hundred and twenty-six point one seven | Four million nine hundred and eighty thousand three hundred and sixteen | Zero | One | Three hundred and twenty-seven point seven eight | 330.2300 | Three hundred and twenty-three point two | Three hundred and twenty-six point one seven | Four million nine hundred and eighty thousand three hundred and sixteen | TSLA |
| One hundred and three | 2017-10-25 | Three hundred and thirty-six point seven | 337.5000 | Three hundred and twenty-three point five six | Three hundred and twenty-five point eight four | Eight million five hundred and forty-seven thousand seven hundred and sixty-four | Zero | One | Three hundred and thirty-six point seven | 337.5000 | Three hundred and twenty-three point five six | Three hundred and twenty-five point eight four | Eight million five hundred and forty-seven thousand seven hundred and sixty-four | TSLA |
| One hundred and four | 2017-10-24 | Three hundred and thirty-eight point eight | 342.8000 | Three hundred and thirty-six point one six | Three hundred and thirty-seven point three four | Four million four hundred and sixty-three thousand eight hundred and seven | Zero | One | Three hundred and thirty-eight point eight | 342.8000 | Three hundred and thirty-six point one six | Three hundred and thirty-seven point three four | Four million four hundred and sixty-three thousand eight hundred and seven | TSLA |
| One hundred and five | 2017-10-23 | Three hundred and forty-nine point eight eight | 349.9500 | Three hundred and thirty-six point two five | Three hundred and thirty-seven point zero two | Five million seven hundred and fifteen thousand eight hundred and seventeen | Zero | One | Three hundred and forty-nine point eight eight | 349.9500 | Three hundred and thirty-six point two five | Three hundred and thirty-seven point zero two | Five million seven hundred and fifteen thousand eight hundred and seventeen | TSLA |
| One hundred and six | 2017-10-20 | Three hundred and fifty-two point six nine | 354.5500 | Three hundred and forty-four point three four | Three hundred and forty-five point one | Four million eight hundred and eighty-eight thousand two hundred and twenty-one | Zero | One | Three hundred and fifty-two point six nine | 354.5500 | Three hundred and forty-four point three four | Three hundred and forty-five point one | Four million eight hundred and eighty-eight thousand two hundred and twenty-one | TSLA |
| One hundred and seven | 2017-10-19 | Three hundred and fifty-five point five six | 357.1465 | Three hundred and forty-eight point two | Three hundred and fifty-one point eight one | Five million thirty-two thousand eight hundred and eighty-four | Zero | One | Three hundred and fifty-five point five six | 357.1465 | Three hundred and forty-eight point two | Three hundred and fifty-one point eight one | Five million thirty-two thousand eight hundred and eighty-four | TSLA |
| One hundred and eight | 2017-10-18 | Three hundred and fifty-five point nine seven | 363.0000 | Three hundred and fifty-four point one three | Three hundred and fifty-nine point six five | Four million eight hundred and ninety-eight thousand eight hundred and eight | Zero | One | Three hundred and fifty-five point nine seven | 363.0000 | Three hundred and fifty-four point one three | Three hundred and fifty-nine point six five | Four million eight hundred and ninety-eight thousand eight hundred and eight | TSLA |
| One hundred and nine | 2017-10-17 | Three hundred and fifty point nine one | 356.2200 | Three hundred and fifty point zero seven | Three hundred and fifty-five point seven five | Three million two hundred and eighty thousand six hundred and seventy | Zero | One | Three hundred and fifty point nine one | 356.2200 | Three hundred and fifty point zero seven | Three hundred and fifty-five point seven five | Three million two hundred and eighty thousand six hundred and seventy | TSLA |

或者我们可以选择一组行和列:

In[]: 
df[100:110][['Close', 'Volume']]

Out[]: 
        Close   Volume
100 320.08  4236029.0
101 320.87  6942493.0
102 326.17  4980316.0
103 325.84  8547764.0
104 337.34  4463807.0
105 337.02  5715817.0
106 345.10  4888221.0
107 351.81  5032884.0
108 359.65  4898808.0
109 355.75  3280670.0

通过选择。loc

使用df.loc,我们可以使用标签进行相同的选择:

要选择一组行，我们可以使用索引号作为标签编写以下代码:

In[]: 
df.loc[100:110]

Out[]:

|
| 日期 | 打开 | 高的 | 低的 | 关闭 | 卷 | 除息 | 分流比 | adopen | AdjHigh | AdjLow | 接近的 | AdjVolume | 名字 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| One hundred | 2017-10-30 | Three hundred and nineteen point one eight | 323.7800 | Three hundred and seventeen point two five | Three hundred and twenty point zero eight | Four million two hundred and thirty-six thousand and twenty-nine | Zero | One | Three hundred and nineteen point one eight | 323.7800 | Three hundred and seventeen point two five | Three hundred and twenty point zero eight | Four million two hundred and thirty-six thousand and twenty-nine | TSLA |
| One hundred and one | 2017-10-27 | Three hundred and nineteen point seven five | 324.5900 | Three hundred and sixteen point six six | Three hundred and twenty point eight seven | Six million nine hundred and forty-two thousand four hundred and ninety-three | Zero | One | Three hundred and nineteen point seven five | 324.5900 | Three hundred and sixteen point six six | Three hundred and twenty point eight seven | Six million nine hundred and forty-two thousand four hundred and ninety-three | TSLA |
| One hundred and two | 2017-10-26 | Three hundred and twenty-seven point seven eight | 330.2300 | Three hundred and twenty-three point two | Three hundred and twenty-six point one seven | Four million nine hundred and eighty thousand three hundred and sixteen | Zero | One | Three hundred and twenty-seven point seven eight | 330.2300 | Three hundred and twenty-three point two | Three hundred and twenty-six point one seven | Four million nine hundred and eighty thousand three hundred and sixteen | TSLA |
| One hundred and three | 2017-10-25 | Three hundred and thirty-six point seven | 337.5000 | Three hundred and twenty-three point five six | Three hundred and twenty-five point eight four | Eight million five hundred and forty-seven thousand seven hundred and sixty-four | Zero | One | Three hundred and thirty-six point seven | 337.5000 | Three hundred and twenty-three point five six | Three hundred and twenty-five point eight four | Eight million five hundred and forty-seven thousand seven hundred and sixty-four | TSLA |
| One hundred and four | 2017-10-24 | Three hundred and thirty-eight point eight | 342.8000 | Three hundred and thirty-six point one six | Three hundred and thirty-seven point three four | Four million four hundred and sixty-three thousand eight hundred and seven | Zero | One | Three hundred and thirty-eight point eight | 342.8000 | Three hundred and thirty-six point one six | Three hundred and thirty-seven point three four | Four million four hundred and sixty-three thousand eight hundred and seven | TSLA |
| One hundred and five | 2017-10-23 | Three hundred and forty-nine point eight eight | 349.9500 | Three hundred and thirty-six point two five | Three hundred and thirty-seven point zero two | Five million seven hundred and fifteen thousand eight hundred and seventeen | Zero | One | Three hundred and forty-nine point eight eight | 349.9500 | Three hundred and thirty-six point two five | Three hundred and thirty-seven point zero two | Five million seven hundred and fifteen thousand eight hundred and seventeen | TSLA |
| One hundred and six | 2017-10-20 | Three hundred and fifty-two point six nine | 354.5500 | Three hundred and forty-four point three four | Three hundred and forty-five point one | Four million eight hundred and eighty-eight thousand two hundred and twenty-one | Zero | One | Three hundred and fifty-two point six nine | 354.5500 | Three hundred and forty-four point three four | Three hundred and forty-five point one | Four million eight hundred and eighty-eight thousand two hundred and twenty-one | TSLA |
| One hundred and seven | 2017-10-19 | Three hundred and fifty-five point five six | 357.1465 | Three hundred and forty-eight point two | Three hundred and fifty-one point eight one | Five million thirty-two thousand eight hundred and eighty-four | Zero | One | Three hundred and fifty-five point five six | 357.1465 | Three hundred and forty-eight point two | Three hundred and fifty-one point eight one | Five million thirty-two thousand eight hundred and eighty-four | TSLA |
| One hundred and eight | 2017-10-18 | Three hundred and fifty-five point nine seven | 363.0000 | Three hundred and fifty-four point one three | Three hundred and fifty-nine point six five | Four million eight hundred and ninety-eight thousand eight hundred and eight | Zero | One | Three hundred and fifty-five point nine seven | 363.0000 | Three hundred and fifty-four point one three | Three hundred and fifty-nine point six five | Four million eight hundred and ninety-eight thousand eight hundred and eight | TSLA |
| One hundred and nine | 2017-10-17 | Three hundred and fifty point nine one | 356.2200 | Three hundred and fifty point zero seven | Three hundred and fifty-five point seven five | Three million two hundred and eighty thousand six hundred and seventy | Zero | One | Three hundred and fifty point nine one | 356.2200 | Three hundred and fifty point zero seven | Three hundred and fifty-five point seven five | Three million two hundred and eighty thousand six hundred and seventy | TSLA |

或者我们可以像前面一样选择一组行和列:

In[]: 
df.loc[100:110, ['Close', 'Volume']]

Out[]:
    Close   Volume
100 320.08  4236029.0
101 320.87  6942493.0
102 326.17  4980316.0
103 325.84  8547764.0
104 337.34  4463807.0
105 337.02  5715817.0
106 345.10  4888221.0
107 351.81  5032884.0
108 359.65  4898808.0
109 355.75  3280670.0
110 350.60  5353262.0

通过选择。iloc

通过df.iloc,我们可以使用整数位置进行相同的选择:

In[]: 
df.iloc[100:110]

Out[]:

|
| 日期 | 打开 | 高的 | 低的 | 关闭 | 卷 | 除息 | 分流比 | adopen | 和高 | AdjLow | 接近的 | AdjVolume | 名字 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| One hundred | 2017-10-30 | Three hundred and nineteen point one eight | 323.7800 | Three hundred and seventeen point two five | Three hundred and twenty point zero eight | Four million two hundred and thirty-six thousand and twenty-nine | Zero | One | Three hundred and nineteen point one eight | 323.7800 | Three hundred and seventeen point two five | Three hundred and twenty point zero eight | Four million two hundred and thirty-six thousand and twenty-nine | TSLA |
| One hundred and one | 2017-10-27 | Three hundred and nineteen point seven five | 324.5900 | Three hundred and sixteen point six six | Three hundred and twenty point eight seven | Six million nine hundred and forty-two thousand four hundred and ninety-three | Zero | One | Three hundred and nineteen point seven five | 324.5900 | Three hundred and sixteen point six six | Three hundred and twenty point eight seven | Six million nine hundred and forty-two thousand four hundred and ninety-three | TSLA |
| One hundred and two | 2017-10-26 | Three hundred and twenty-seven point seven eight | 330.2300 | Three hundred and twenty-three point two | Three hundred and twenty-six point one seven | Four million nine hundred and eighty thousand three hundred and sixteen | Zero | One | Three hundred and twenty-seven point seven eight | 330.2300 | Three hundred and twenty-three point two | Three hundred and twenty-six point one seven | Four million nine hundred and eighty thousand three hundred and sixteen | TSLA |
| One hundred and three | 2017-10-25 | Three hundred and thirty-six point seven | 337.5000 | Three hundred and twenty-three point five six | Three hundred and twenty-five point eight four | Eight million five hundred and forty-seven thousand seven hundred and sixty-four | Zero | One | Three hundred and thirty-six point seven | 337.5000 | Three hundred and twenty-three point five six | Three hundred and twenty-five point eight four | Eight million five hundred and forty-seven thousand seven hundred and sixty-four | TSLA |
| One hundred and four | 2017-10-24 | Three hundred and thirty-eight point eight | 342.8000 | Three hundred and thirty-six point one six | Three hundred and thirty-seven point three four | Four million four hundred and sixty-three thousand eight hundred and seven | Zero | One | Three hundred and thirty-eight point eight | 342.8000 | Three hundred and thirty-six point one six | Three hundred and thirty-seven point three four | Four million four hundred and sixty-three thousand eight hundred and seven | TSLA |
| One hundred and five | 2017-10-23 | Three hundred and forty-nine point eight eight | 349.9500 | Three hundred and thirty-six point two five | Three hundred and thirty-seven point zero two | Five million seven hundred and fifteen thousand eight hundred and seventeen | Zero | One | Three hundred and forty-nine point eight eight | 349.9500 | Three hundred and thirty-six point two five | Three hundred and thirty-seven point zero two | Five million seven hundred and fifteen thousand eight hundred and seventeen | TSLA |
| One hundred and six | 2017-10-20 | Three hundred and fifty-two point six nine | 354.5500 | Three hundred and forty-four point three four | Three hundred and forty-five point one | Four million eight hundred and eighty-eight thousand two hundred and twenty-one | Zero | One | Three hundred and fifty-two point six nine | 354.5500 | Three hundred and forty-four point three four | Three hundred and forty-five point one | Four million eight hundred and eighty-eight thousand two hundred and twenty-one | TSLA |
| One hundred and seven | 2017-10-19 | Three hundred and fifty-five point five six | 357.1465 | Three hundred and forty-eight point two | Three hundred and fifty-one point eight one | Five million thirty-two thousand eight hundred and eighty-four | Zero | One | Three hundred and fifty-five point five six | 357.1465 | Three hundred and forty-eight point two | Three hundred and fifty-one point eight one | Five million thirty-two thousand eight hundred and eighty-four | TSLA |
| One hundred and eight | 2017-10-18 | Three hundred and fifty-five point nine seven | 363.0000 | Three hundred and fifty-four point one three | Three hundred and fifty-nine point six five | Four million eight hundred and ninety-eight thousand eight hundred and eight | Zero | One | Three hundred and fifty-five point nine seven | 363.0000 | Three hundred and fifty-four point one three | Three hundred and fifty-nine point six five | Four million eight hundred and ninety-eight thousand eight hundred and eight | TSLA |
| One hundred and nine | 2017-10-17 | Three hundred and fifty point nine one | 356.2200 | Three hundred and fifty point zero seven | Three hundred and fifty-five point seven five | Three million two hundred and eighty thousand six hundred and seventy | Zero | One | Three hundred and fifty point nine one | 356.2200 | Three hundred and fifty point zero seven | Three hundred and fifty-five point seven five | Three million two hundred and eighty thousand six hundred and seventy | TSLA |

在最后一个例子中，我们使用索引作为整数位置，而不是标签。

我们可以像前面一样选择一组行和列:

In[]: 
df.iloc[100:110, [3, 4]]

Out[]:
      Low   Close
100 317.25  320.08
101 316.66  320.87
102 323.20  326.17
103 323.56  325.84
104 336.16  337.34
105 336.25  337.02
106 344.34  345.10
107 348.20  351.81
108 354.13  359.65
109 350.07  355.75

布尔索引

到目前为止，在 Python Pandas 教程中，我们已经按照标签或位置对数据子集进行了切片。现在让我们看看如何选择符合某些标准的数据。我们通过布尔索引来实现这一点。我们可以使用与 Numpy 数组相似的标准。这里我们只向您展示两个说明性的例子。这并不足以让你熟悉它，所以鼓励你去查阅文档和本章末尾的进一步阅读来了解更多。

  • 我们可以过滤大于(小于)一个数字的数据。
In[]: 
df[df.Close > 110]

Out[]:

|
| 日期 | 打开 | 高的 | 低的 | 关闭 | 卷 | 除息 | 分流比 | adopen | 和高 | AdjLow | 接近的 | AdjVolume | 名字 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Zero | 2018-03-27 | Three hundred and four | 304.2700 | 277.1800 | 279.1800 | Thirteen million six hundred and ninety-six thousand one hundred and sixty-eight | Zero | One | Three hundred and four | 304.2700 | 277.1800 | 279.1800 | Thirteen million six hundred and ninety-six thousand one hundred and sixty-eight | TSLA |
| one | 2018-03-26 | Three hundred and seven point three four | 307.5900 | 291.3600 | 304.1800 | Eight million three hundred and twenty-four thousand six hundred and thirty-nine | Zero | One | Three hundred and seven point three four | 307.5900 | 291.3600 | 304.1800 | Eight million three hundred and twenty-four thousand six hundred and thirty-nine | TSLA |
| Two | 2018-03-23 | Three hundred and eleven point two five | 311.6100 | 300.4500 | 301.5400 | Six million six hundred thousand five hundred and thirty-eight | Zero | One | Three hundred and eleven point two five | 311.6100 | 300.4500 | 301.5400 | Six million six hundred thousand five hundred and thirty-eight | TSLA |
|
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |
| One thousand and eighty | 2013-12-09 | One hundred and thirty-seven | 141.7000 | 134.2100 | 141.6000 | Nine million sixty-one thousand five hundred | Zero | One | One hundred and thirty-seven | 141.7000 | 134.2100 | 141.6000 | Nine million sixty-one thousand five hundred | TSLA |
| One thousand and eighty-one | 2013-12-06 | One hundred and forty-one point five one | 142.4900 | 136.3000 | 137.3600 | Seven million nine hundred and nine thousand six hundred | Zero | One | One hundred and forty-one point five one | 142.4900 | 136.3000 | 137.3600 | Seven million nine hundred and nine thousand six hundred | TSLA |
| One thousand and eighty-two | 2013-12-05 | One hundred and forty point one five | 143.3500 | 139.5000 | 140.4800 | Nine million two hundred and eighty-eight thousand four hundred | Zero | One | One hundred and forty point one five | 143.3500 | 139.5000 | 140.4800 | Nine million two hundred and eighty-eight thousand four hundred | TSLA |

1083 行× 14 列

In[]: 
df[(df['Close'] > 110) | (df['Close'] < 120)]

Out[]:
`

|
| 日期 | 打开 | 高的 | 低的 | 关闭 | 卷 | 除息 | 分流比 | adopen | 和高 | AdjLow | 接近的 | AdjVolume | 名字 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Zero | 2018-03-27 | Three hundred and four | 304.2700 | 277.1800 | 279.1800 | Thirteen million six hundred and ninety-six thousand one hundred and sixty-eight | Zero | One | Three hundred and four | 304.2700 | 277.1800 | 279.1800 | Thirteen million six hundred and ninety-six thousand one hundred and sixty-eight | TSLA |
| one | 2018-03-26 | Three hundred and seven point three four | 307.5900 | 291.3600 | 304.1800 | Eight million three hundred and twenty-four thousand six hundred and thirty-nine | Zero | One | Three hundred and seven point three four | 307.5900 | 291.3600 | 304.1800 | Eight million three hundred and twenty-four thousand six hundred and thirty-nine | TSLA |
| Two | 2018-03-23 | Three hundred and eleven point two five | 311.6100 | 300.4500 | 301.5400 | Six million six hundred thousand five hundred and thirty-eight | Zero | One | Three hundred and eleven point two five | 311.6100 | 300.4500 | 301.5400 | Six million six hundred thousand five hundred and thirty-eight | TSLA |
|
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |
| One thousand and eighty | 2013-12-09 | One hundred and thirty-seven | 141.7000 | 134.2100 | 141.6000 | Nine million sixty-one thousand five hundred | Zero | One | One hundred and thirty-seven | 141.7000 | 134.2100 | 141.6000 | Nine million sixty-one thousand five hundred | TSLA |
| One thousand and eighty-one | 2013-12-06 | One hundred and forty-one point five one | 142.4900 | 136.3000 | 137.3600 | Seven million nine hundred and nine thousand six hundred | Zero | One | One hundred and forty-one point five one | 142.4900 | 136.3000 | 137.3600 | Seven million nine hundred and nine thousand six hundred | TSLA |
| One thousand and eighty-two | 2013-12-05 | One hundred and forty point one five | 143.3500 | 139.5000 | 140.4800 | Nine million two hundred and eighty-eight thousand four hundred | Zero | One | One hundred and forty point one five | 143.3500 | 139.5000 | 140.4800 | Nine million two hundred and eighty-eight thousand four hundred | TSLA |

1083 行× 14 列

操纵 Python 熊猫数据帧

当我们处理数据时，最常见的结构是数据帧。我们已经在 Python 熊猫教程中看到了如何创建它们、进行选择和查找数据。我们现在将看到如何操作 Python Pandas 数据帧，以将其转换为另一个 Python Pandas 数据帧，该数据帧具有我们的问题所需的形式。

我们将看到如何对它进行排序、重新索引、消除不需要的(或虚假的)数据、添加或删除列以及更新值。

。移调

Python Pandas 数据帧转置函数T允许我们将行转置为列，逻辑上将列转置为行:

In[]: import pandas as pd
      df=pd.read_csv('TSLA.csv' )
      df2=df[100:110][['Close', 'Volume']]

      df2.T

Out[]:

|
| One hundred | One hundred and one | One hundred and two | One hundred and three | One hundred and four | One hundred and five | One hundred and six | One hundred and seven | One hundred and eight | One hundred and nine |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 关闭 | Three hundred and twenty point zero eight | Three hundred and twenty point eight seven | Three hundred and twenty-six point one seven | Three hundred and twenty-five point eight four | Three hundred and thirty-seven point three four | Three hundred and thirty-seven point zero two | Three hundred and forty-five point one | Three hundred and fifty-one point eight one | Three hundred and fifty-nine point six five | Three hundred and fifty-five point seven five |
| 卷 | Four million two hundred and thirty-six thousand and twenty-nine | Six million nine hundred and forty-two thousand four hundred and ninety-three | Four million nine hundred and eighty thousand three hundred and sixteen | Eight million five hundred and forty-seven thousand seven hundred and sixty-four | Four million four hundred and sixty-three thousand eight hundred and seven | Five million seven hundred and fifteen thousand eight hundred and seventeen | Four million eight hundred and eighty-eight thousand two hundred and twenty-one | Five million thirty-two thousand eight hundred and eighty-four | Four million eight hundred and ninety-eight thousand eight hundred and eight | Three million two hundred and eighty thousand six hundred and seventy |

。排序索引()

当我们使用 Python Pandas Dataframe 时，通常会添加或删除行，按列排序等。这就是为什么拥有一个能够让我们轻松舒适地按照索引对 Python Pandas 数据帧进行排序的函数非常重要。我们用 Pandas DataFrame 的sort_index函数来做这件事。

In[]:
 df.sort_index()

Out[]:

|
| 日期 | 打开 | 高的 | 低的 | 关闭 | 卷 | 除息 | 分流比 | adopen | 和高 | AdjLow | 接近的 | AdjVolume | 名字 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Zero | 2018-03-27 | Three hundred and four | 304.2700 | 277.1800 | 279.1800 | Thirteen million six hundred and ninety-six thousand one hundred and sixty-eight | Zero | One | Three hundred and four | 304.2700 | 277.1800 | 279.1800 | Thirteen million six hundred and ninety-six thousand one hundred and sixty-eight | TSLA |
| one | 2018-03-26 | Three hundred and seven point three four | 307.5900 | 291.3600 | 304.1800 | Eight million three hundred and twenty-four thousand six hundred and thirty-nine | Zero | One | Three hundred and seven point three four | 307.5900 | 291.3600 | 304.1800 | Eight million three hundred and twenty-four thousand six hundred and thirty-nine | TSLA |
| Two | 2018-03-23 | Three hundred and eleven point two five | 311.6100 | 300.4500 | 301.5400 | Six million six hundred thousand five hundred and thirty-eight | Zero | One | Three hundred and eleven point two five | 311.6100 | 300.4500 | 301.5400 | Six million six hundred thousand five hundred and thirty-eight | TSLA |
|
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |

。排序值()

有时，我们可能对按照某一列或者甚至几列作为标准对 Python Pandas 数据帧进行排序感兴趣。例如，按名字对列进行排序，按姓氏对第二个条件进行排序。我们用 Python Pandas DataFrame 的sort_values函数来做这件事。

In[]: 
df.sort_values(by='Close')

Out[]:

|
| 日期 | 打开 | 高的 | 低的 | 关闭 | 卷 | 除息 | 分流比 | adopen | 和高 | AdjLow | 接近的 | AdjVolume | 名字 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| One thousand and eighty-one | 2013-12-06 | One hundred and forty-one point five one | 142.4900 | 136.3000 | 137.3600 | Seven million nine hundred and nine thousand six hundred | Zero | One | One hundred and forty-one point five one | 142.4900 | 136.3000 | 137.3600 | Seven million nine hundred and nine thousand six hundred | TSLA |
| One thousand and fifty-seven | 2014-01-13 | One hundred and forty-five point seven eight | 147.0000 | 137.8200 | 139.3400 | Six million three hundred and sixteen thousand one hundred | Zero | One | One hundred and forty-five point seven eight | 147.0000 | 137.8200 | 139.3400 | Six million three hundred and sixteen thousand one hundred | TSLA |
| One thousand and seventy-eight | 2013-12-11 | One hundred and forty-one point eight eight | 143.0500 | 139.4900 | 139.6500 | Seven million one hundred and thirty-seven thousand eight hundred | Zero | One | One hundred and forty-one point eight eight | 143.0500 | 139.4900 | 139.6500 | Seven million one hundred and thirty-seven thousand eight hundred | TSLA |
|
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |

In[]: 
df.sort_values(by=['Open', 'Close'])

Out[]:

|
| 日期 | 打开 | 高的 | 低的 | 关闭 | 卷 | 除息 | 分流比 | adopen | 和高 | AdjLow | 接近的 | AdjVolume | 名字 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| One thousand and eighty | 2013-12-09 | One hundred and thirty-seven | 141.7000 | 134.2100 | 141.6000 | Nine million sixty-one thousand five hundred | Zero | One | One hundred and thirty-seven | 141.7000 | 134.2100 | 141.6000 | Nine million sixty-one thousand five hundred | TSLA |
| One thousand and seventy-seven | 2013-12-12 | One hundred and thirty-nine point seven | 148.2400 | 138.5300 | 147.4700 | Ten million seven hundred and sixty-seven thousand eight hundred | Zero | One | One hundred and thirty-nine point seven | 148.2400 | 138.5300 | 147.4700 | Ten million seven hundred and sixty-seven thousand eight hundred | TSLA |
| One thousand and seventy-nine | 2013-12-10 | One hundred and forty point zero five | 145.8700 | 139.8600 | 142.1900 | Ten million seven hundred and forty-eight thousand two hundred | Zero | One | One hundred and forty point zero five | 145.8700 | 139.8600 | 142.1900 | Ten million seven hundred and forty-eight thousand two hundred | TSLA |
|
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |

。reindex()

Python Pandas 的 reindex 函数让我们重新排列系列或数据帧的索引，当我们需要重新组织索引以满足某些标准时，这很有用。

例如，我们可以使用之前创建的序列或数据帧来改变原始索引。例如，当索引是一个标签时，我们可以根据需要进行重组:

In[]: import pandas as pd
      import numpy as np
      df = pd.DataFrame(np.random.randn(5), index=['a', 'b', 'c', 'd', 'e'])

      df

Out[]:

|
| Zero |
| --- | --- |
| a | -0.134133 |
| b | -0.586051 |
| c | 1.179358 |
| d | 0.433142 |
| e | -0.365686 |

现在，我们可以将索引重组如下:

In[]: 
df.reindex(['b', 'a', 'd', 'c', 'e'])

Out[]:

|
| Zero |
| --- | --- |
| b | -0.586051 |
| a | -0.134133 |
| d | 0.433142 |
| c | 1.179358 |
| e | -0.365686 |

当索引是数字时，我们可以使用相同的函数来手动排序索引:

In[]: 
 import pandas as pd
      import numpy as np
      df = pd.DataFrame(np.random.randn(5))
      df.reindex([4,3,2,1,0])

Out[]:

|
| Zero |
| --- | --- |
| four | 1.058589 |
| three | 1.194400 |
| Two | -0.645806 |
| one | 0.836606 |
| Zero | 1.288102 |

在本节的后面，我们将看到如何工作和重组日期和时间索引。

添加新列。例如，对于 df['新列'] = 1

Python Pandas 数据帧的另一个有趣特性是可以向现有数据帧添加新列。

例如，我们可以向之前创建的随机数据帧添加一个新列:

In[]: 
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5))

Out[]:

|
| Zero |
| --- | --- |
| Zero | 0.238304 |
| one | 2.068558 |
| Two | 1.015650 |
| three | 0.506208 |
| four | 0.214760 |

要添加一个新列，我们只需要在数据帧中包含新列名并分配一个初始化值，或者给新列分配一个 Pandas 系列或其他数据帧中的另一列。

In[]: 
df['new']=1
df

Out[]:

|
|
| Zero | 新的 |
| --- | --- | --- | --- |
|
| Zero | 0.238304 | one |
|
| one | 2.068558 | one |
|
| Two | 1.015650 | one |
|
| three | 0.506208 | one |
|
| four | 0.214760 | one |

删除现有列

同样，我们可以从 Python Pandas 数据帧中删除一个或多个列。让我们用随机值创建一个 5 行 4 列的数据帧来删除一列。

In[]: 

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 4))
df

Out[]:

|
|
| Zero | one | Two | three |
| --- | --- | --- | --- | --- | --- |
|
| Zero | -1.171562 | -0.086348 | -1.971855 | 1.168017 |
|
| one | -0.408317 | -0.061397 | -0.542212 | -1.412755 |
|
| Two | -0.365539 | -0.587147 | 1.494690 | 1.756105 |
|
| three | 0.642882 | 0.924202 | 0.517975 | -0.914366 |
|
| four | 0.777869 | -0.431151 | -0.401093 | 0.145646 |

现在，我们可以删除通过索引或标签(如果有)指定的列:

In[]: 
del df[0]

Out[]:

|
|
| one | Two | three |
| --- | --- | --- | --- | --- |
|
| Zero | -0.086348 | -1.971855 | 1.168017 |
|
| one | -0.061397 | -0.542212 | -1.412755 |
|
| Two | -0.587147 | 1.494690 | 1.756105 |
|
| three | 0.924202 | 0.517975 | -0.914366 |
|
| four | -0.431151 | -0.401093 | 0.145646 |

In[]: 
df['new']=1
df

Out[]:

|
|
| Zero | 新的 |
| --- | --- | --- | --- |
|
| Zero | 0.238304 | one |
|
| one | 2.068558 | one |
|
| Two | 1.015650 | one |
|
| three | 0.506208 | one |

In[]: 
del df['new']

Out[]:

|
|
| Zero |
| --- | --- | --- |
|
| Zero | 0.238304 |
|
| one | 2.068558 |
|
| Two | 1.015650 |
|
| three | 0.506208 |

。位于

使用at,我们可以通过行和列标签定位特定值，如下所示:

In[]: 
import pandas as pd
import numpy as np
df=pd.DataFrame(np.random.randn(5,4), index=['a','b','c','d','e'], columns=['A', 'B', 'C', 'D'])
print(df)

df.at['a', 'A']

Out[]:

|
| A | B | C | D |
| --- | --- | --- | --- | --- |
| a | 0.996496 | -0.165002 | 0.727912 | 0.564858 |
| b | -0.388169 | 1.171039 | -0.231934 | -1.124595 |
| c | -1.385129 | 0.299195 | 0.573570 | -1.736860 |
| d | 1.222447 | -0.312667 | 0.957139 | -0.054156 |
| e | 1.188335 | 0.679921 | 1.508681 | -0.677776 |

In[]: 
df.at['a', 'A']

Out[]: 

0.9964957014209125

也可以用相同的功能分配一个新值:

In[]: 
df.at['a', 'A'] = 0

Out[]:

|
| A | B | C | D |
| --- | --- | --- | --- | --- |
| a | 0.000000 | -0.165002 | 0.727912 | 0.564858 |
| b | -0.388169 | 1.171039 | -0.231934 | -1.124595 |
| c | -1.385129 | 0.299195 | 0.573570 | -1.736860 |
| d | 1.222447 | -0.312667 | 0.957139 | -0.054156 |
| e | 1.188335 | 0.679921 | 1.508681 | -0.677776 |

。iat

使用iat,我们可以通过行和列索引定位特定值，如下所示:

In[]: 
 import pandas as pd
      import numpy as np
      df=pd.DataFrame(np.random.randn(5,4), index=['a','b','c','d','e'], columns=['A', 'B', 'C', 'D'])
      print(df)

      df.iat[0, 0]

Out[]: 
0.996496

也可以用相同的功能分配一个新值:

In[]: 
df.iat[0, 0] = 0

Out[]:

|
| A | B | C | D |
| --- | --- | --- | --- | --- |
| a | 0.000000 | -0.165002 | 0.727912 | 0.564858 |
| b | -0.388169 | 1.171039 | -0.231934 | -1.124595 |
| c | -1.385129 | 0.299195 | 0.573570 | -1.736860 |
| d | 1.222447 | -0.312667 | 0.957139 | -0.054156 |
| e | 1.188335 | 0.679921 | 1.508681 | -0.677776 |

值的条件更新。例如，对于 df[df > 0] = 1

另一个有用的功能是更新符合某些标准的值，例如，更新值大于 0 的值:

In[]: 
import pandas as pd
import numpy as np
df=pd.DataFrame(np.random.randn(5, 4), index=['a','b','c','d','e'], columns=['A', 'B', 'C', 'D'])
print(df)

df[df > 0] = 1
df

Out[]:

|
| A | B | C | D |
| --- | --- | --- | --- | --- |
| a | 1.000000 | -0.082466 | 1.000000 | -0.728372 |
| b | -0.784404 | -0.663096 | -0.595112 | 1.000000 |
| c | -1.460702 | -1.072931 | -0.761314 | 1.000000 |
| d | 1.000000 | 1.000000 | 1.000000 | -0.302310 |
| e | -0.488556 | 1.000000 | -0.798716 | -0.590920 |

我们还可以更新满足某些标准的特定列的值，甚至可以使用几个列作为标准并更新特定的列。

In[]: 
df['A'][df['A'] < 0] = 1
print(df)

Out[]:

|
| A | B | C | D |
| --- | --- | --- | --- | --- |
| a | One | -0.082466 | 1.000000 | -0.728372 |
| b | One | -0.663096 | -0.595112 | 1.000000 |
| c | One | -1.072931 | -0.761314 | 1.000000 |
| d | One | 1.000000 | 1.000000 | -0.302310 |
| e | One | 1.000000 | -0.798716 | -0.590920 |

In[]: 
df['A'][(df['B'] < 0 )& (df['C'] < 0)] = 9
print(df)

Out[]:

|
| A | B | C | D |
| --- | --- | --- | --- | --- |
| a | One | -0.082466 | 1.000000 | -0.728372 |
| b | Nine | -0.663096 | -0.595112 | 1.000000 |
| c | Nine | -1.072931 | -0.761314 | 1.000000 |
| d | One | 1.000000 | 1.000000 | -0.302310 |
| e | One | 1.000000 | -0.798716 | -0.590920 |

。德罗普纳()

偶尔，我们可能会有一个 Python Pandas 数据帧，出于某种原因，它包含 NA 值。当我们进行计算或运算时，这种类型的值通常是有问题的，必须在处理它们之前正确处理。

消除 NA 值的最简单方法是删除包含它的行。

In[]: 
import pandas as pd
import numpy as np
df=pd.DataFrame(np.random.randn(5,4), index=['a','b','c','d','e'], columns=['A', 'B', 'C', 'D'])
print(df)

Out[]:

|
| A | B | C | D |
| --- | --- | --- | --- | --- |
| a | 1.272361 | 1.799535 | -0.593619 | 1.152889 |
| b | -0.318368 | -0.190419 | 0.129420 | 1.551332 |
| c | 0.166951 | 1.669034 | -1.653618 | 0.656313 |
| d | 0.219999 | 0.951074 | 0.442325 | -0.170177 |
| e | 0.312319 | -0.765930 | -1.641234 | -1.388924 |

In[]: 
df['A'][(df['B'] < 0 )& (df['C'] < 0)] = np.nan
print(df)

Out[]:

|
| A | B | C | D |
| --- | --- | --- | --- | --- |
| a | 1.272361 | 1.799535 | -0.593619 | 1.152889 |
| b | -0.318368 | -0.190419 | 0.129420 | 1.551332 |
| c | 0.166951 | 1.669034 | -1.653618 | 0.656313 |
| d | 0.219999 | 0.951074 | 0.442325 | -0.170177 |
| e | 圆盘烤饼 | -0.765930 | -1.641234 | -1.388924 |

In[]: 
df=df.dropna()
print(df)

Out[]:

|
| A | B | C | D |
| --- | --- | --- | --- | --- |
| a | 1.272361 | 1.799535 | -0.593619 | 1.152889 |
| b | -0.318368 | -0.190419 | 0.129420 | 1.551332 |
| c | 0.166951 | 1.669034 | -1.653618 | 0.656313 |
| d | 0.219999 | 0.951074 | 0.442325 | -0.170177 |

在这里，我们删除了在其任何列中具有 NaN 值的整行，但是我们也可以指定删除其任何值为 NaN 的列:

df=df.dropna(axis=1)
print(df)

我们可以指定单个 NaN 值是否足以删除行或列，或者是否整行或整列都必须有 NaN 才能删除。

```thon
df=df.dropna(how='all')
print(df)

```py

### 。菲尔娜

通过前面的函数，我们已经看到了如何消除包含一个或所有值的完整行或列。如果行或列中有有效值，这个操作可能会有点激烈。

为此，使用`fillna`函数将 NaN 值替换为某个固定值是很有趣的。

In[]:
import pandas as pd
import numpy as np
df=pd.DataFrame(np.random.randn(5,4), index=['a','b','c','d','e'], columns=['A', 'B', 'C', 'D'])
print(df)

Out[]:


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| a | 1.272361 | 1.799535 | -0.593619 | 1.152889 |
| b | -0.318368 | -0.190419 | 0.129420 | 1.551332 |
| c | 0.166951 | 1.669034 | -1.653618 | 0.656313 |
| d | 0.219999 | 0.951074 | 0.442325 | -0.170177 |
| e | 0.312319 | -0.765930 | -1.641234 | -1.388924 |

In[]:
df['A'][(df['B'] < 0 )& (df['C'] < 0)] = np.nan
print(df)

Out[]:


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| a | 1.272361 | 1.799535 | -0.593619 | 1.152889 |
| b | -0.318368 | -0.190419 | 0.129420 | 1.551332 |
| c | 0.166951 | 1.669034 | -1.653618 | 0.656313 |
| d | 0.219999 | 0.951074 | 0.442325 | -0.170177 |
| e | 圆盘烤饼 | -0.765930 | -1.641234 | -1.388924 |

In[]:
df=df.fillna(999)
print(df)

Out[]:


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| a | 1.272361 | 1.799535 | -0.593619 | 1.152889 |
| b | -0.318368 | -0.190419 | 0.129420 | 1.551332 |
| c | 0.166951 | 1.669034 | -1.653618 | 0.656313 |
| d | 0.219999 | 0.951074 | 0.442325 | -0.170177 |
| e | Nine hundred and ninety-nine | -0.765930 | -1.641234 | -1.388924 |

### 。应用()

`apply`是一种非常有用的方法，可以在数据帧中使用函数或方法，而不必遍历它。

我们可以对系列或数据帧应用 apply 函数，以便对数据帧的所有行或列应用函数。让我们看一些例子。

假设我们正在处理随机生成的 Python 熊猫数据帧，并且需要应用一个函数。在这个例子中，为了简单起见，我们将创建一个自定义函数来计算一个数字的平方。

In[]:
import pandas as pd
import numpy as np
df=pd.DataFrame(np.random.randn(5,4), index=['a','b','c','d','e'], columns=['A', 'B', 'C', 'D'])
print(df)

Out[]:
`


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| a | -0.633249 | -2.699088 | 0.574052 | 0.652742 |
| b | 0.060295 | -0.150527 | 0.149123 | -0.701216 |
| c | -0.052515 | 0.469481 | 0.899180 | -0.608409 |
| d | -1.352912 | 0.103302 | 0.457878 | -1.897170 |
| e | 0.088279 | 0.418317 | -1.102989 | 0.582455 |

def square_number(number):
return number**2

Test the function

In[]:
square_number(2)

Out[]:
4


现在，让我们通过应用来使用自定义函数:

In[]:
df.apply(square_number, axis=1)

Out[]:


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| a | 0.401005 | 7.285074 | 0.329536 | 0.426073 |
| b | 0.003636 | 0.022658 | 0.022238 | 0.491704 |
| c | 0.002758 | 0.220412 | 0.808524 | 0.370161 |
| d | 1.830372 | 0.010671 | 0.209652 | 3.599253 |
| e | 0.007793 | 0.174989 | 1.216586 | 0.339254 |

这个方法`apply`将函数`square_number`应用于数据帧的所有行。

### 。shift()

`shift`功能允许我们向左或向右移动一行和/或向上或向下移动一列。让我们看一些例子。

首先，我们将向下移动列的值:

In[]:
import pandas as pd
import numpy as np
df=pd.DataFrame(np.random.randn(5,4), index=['a','b','c','d','e'], columns=['A', 'B', 'C', 'D'])
print(df)

Out[]:


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| a | -0.633249 | -2.699088 | 0.574052 | 0.652742 |
| b | 0.060295 | -0.150527 | 0.149123 | -0.701216 |
| c | -0.052515 | 0.469481 | 0.899180 | -0.608409 |
| d | -1.352912 | 0.103302 | 0.457878 | -1.897170 |
| e | 0.088279 | 0.418317 | -1.102989 | 0.582455 |

In[]:
df['D'].shift(1)

Out[]:


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| a | -0.633249 | -2.699088 | 0.574052 | 圆盘烤饼 |
| b | 0.060295 | -0.150527 | 0.149123 | 0.652742 |
| c | -0.052515 | 0.469481 | 0.899180 | -0.701216 |
| d | -1.352912 | 0.103302 | 0.457878 | -0.608409 |
| e | 0.088279 | 0.418317 | -1.102989 | -1.897170 |

我们将向上移动一列的值

In[]:
df['shift'] = df['D'].shift(-1)

Out[]:


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| a | -0.633249 | -2.699088 | 0.574052 | -0.701216 |
| b | 0.060295 | -0.150527 | 0.149123 | -0.608409 |
| c | -0.052515 | 0.469481 | 0.899180 | -1.897170 |
| d | -1.352912 | 0.103302 | 0.457878 | 0.582455 |
| e | 0.088279 | 0.418317 | -1.102989 | 圆盘烤饼 |

这对于比较当前值和先前值非常有用。

## 统计探索性数据分析

Python Pandas DataFrame 允许我们进行一些描述性统计计算，这对我们处理的数据进行初步分析非常有用。来看看一些有用的函数。

### 信息()

了解我们的数据帧的结构和格式是一个很好的做法，`Info`函数正好为我们提供了这一点:

In[]:
import pandas as pd
import numpy as np
df=pd.DataFrame(np.random.randn(5,4), index=['a','b','c','d','e'], columns=['A', 'B', 'C', 'D'])
print(df)

Out[]:


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| a | -0.633249 | -2.699088 | 0.574052 | 0.652742 |
| b | 0.060295 | -0.150527 | 0.149123 | -0.701216 |
| c | -0.052515 | 0.469481 | 0.899180 | -0.608409 |
| d | -1.352912 | 0.103302 | 0.457878 | -1.897170 |
| e | 0.088279 | 0.418317 | -1.102989 | 0.582455 |

In[]:
df.info()

Out[]:
<class 'pandas.core.frame.DataFrame'>
Index: 5 entries, a to e
Data columns (total 5 columns):
A 5 non-null float64
B 5 non-null float64
C 5 non-null float64
D 5 non-null float64
shift 4 non-null float64
dtypes: float64(5)
memory usage: 240.0+ bytes


### 描述()

我们可以通过“描述”功能获得数据框架的统计概览，它给出了平均值、中间值、标准偏差、最大值、最小值、四分位数等。每个数据帧列的。

In[]:
import pandas as pd
import numpy as np
df=pd.DataFrame(np.random.randn(5,4), index=['a','b','c','d','e'], columns=['A', 'B', 'C', 'D'])
print(df)

Out[]:
`


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| a | -0.633249 | -2.699088 | 0.574052 | 0.652742 |
| b | 0.060295 | -0.150527 | 0.149123 | -0.701216 |
| c | -0.052515 | 0.469481 | 0.899180 | -0.608409 |
| d | -1.352912 | 0.103302 | 0.457878 | -1.897170 |
| e | 0.088279 | 0.418317 | -1.102989 | 0.582455 |

In[]:
df.describe()

Out[]:


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| 数数 | 5.000000 | 5.000000 | 5.000000 | 5.000000 |
| 意思是 | -0.378020 | -0.371703 | 0.195449 | -0.394319 |
| 标准 | 0.618681 | 1.325046 | 0.773876 | 1.054633 |
| 部 | -1.352912 | -2.699088 | -1.102989 | -1.897170 |
| 25% | -0.633249 | -0.150527 | 0.149123 | -0.701216 |
| 50% | -0.052515 | 0.103302 | 0.457878 | -0.608409 |
| 75% | 0.060295 | 0.418317 | 0.574052 | 0.582455 |
| 最大 | 0.088279 | 0.469481 | 0.899180 | 0.652742 |

### 。值计数()

函数`value_counts`计算指定列的重复值:

In[]:
df['A'].value_counts()

Out[]:
0.088279 1
-0.052515 1
0.060295 1
-0.633249 1
-1.352912 1
Name: A, dtype: int64


### 。平均值()

我们可以通过`mean`函数获得特定列或行的平均值。

In[]:
df['A'].mean() # specifying a column
Out[]:
-0.3780203497252693
`

In[]:
df.mean() # by column
df.mean(axis=0) # by column

Out[]:
A -0.378020
B -0.371703
C 0.195449
D -0.394319
shift -0.638513
dtype: float64
`

In[]:
df.mean(axis=1) # by row

Out[]:
a -0.526386
b 0.002084
c 0.001304
d -0.659462
e -0.382222
dtype: float64


### 。标准()

我们可以通过`std`函数获得特定列或行的标准偏差。

In[]:
df['A'].std() # specifying a column

Out[]:
0.6186812554819784
`

In[]:
df.std() # by column
df.std(axis=0) # by column

Out[]:
A 0.618681
B 1.325046
C 0.773876
D 1.054633
shift 1.041857
dtype: float64
`

In[]:
df.std(axis=1) # by row

Out[]:
a 1.563475
b 0.491499
c 0.688032
d 0.980517
e 1.073244
dtype: float64


## 过滤 Python 熊猫数据帧

我们已经看到了如何在 Python Pandas 数据框架中过滤数据，包括使用一些逻辑标准过滤行或列的逻辑语句。让我们记住一些例子:

例如，我们将筛选列“A”大于零的行:

In[]:
import numpy as np
df=pd.DataFrame(np.random.randn(5,4), index=['a','b','c','d','e'], columns=['A', 'B', 'C', 'D'])
print(df)

Out[]:
`


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| a | -0.633249 | -2.699088 | 0.574052 | 0.652742 |
| b | 0.060295 | -0.150527 | 0.149123 | -0.701216 |
| c | -0.052515 | 0.469481 | 0.899180 | -0.608409 |
| d | -1.352912 | 0.103302 | 0.457878 | -1.897170 |
| e | 0.088279 | 0.418317 | -1.102989 | 0.582455 |

In[]:
df_filtered = df[df['A'] > 0]
print(df_filtered)

Out[]:


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| b | 0.060295 | -0.150527 | 0.149123 | -0.701216 |
| e | 0.088279 | 0.418317 | -1.102989 | 0.582455 |

我们还可以组合逻辑语句，我们将过滤所有列‘A’和‘B’的值大于零的行。

In[]:
df_filtered = df[(df['A'] > 0) & (df['B'] > 0)] print(df_filtered)

Out[]:


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| e | 0.088279 | 0.418317 | -1.102989 | 0.582455 |

## 迭代 Python 熊猫数据帧

我们可以逐行遍历 Python Pandas 数据帧，在每次迭代中进行操作，让我们看一些例子。

In[]:
for item in df.iterrows():
print(item)

Out[]:
('a', A -0.633249
B -2.699088
C 0.574052
D 0.652742
shift NaN
Name: a, dtype: float64)
('b', A 0.060295
B -0.150527
C 0.149123
D -0.701216
shift 0.652742
Name: b, dtype: float64)
('c', A -0.052515
B 0.469481
C 0.899180
D -0.608409
shift -0.701216
Name: c, dtype: float64)
('d', A -1.352912
B 0.103302
C 0.457878
D -1.897170
shift -0.608409
Name: d, dtype: float64)
('e', A 0.088279
B 0.418317
C -1.102989
D 0.582455
shift -1.897170
Name: e, dtype: float64)


## Python Pandas 数据帧上的合并、追加和连接操作

Python Pandas 数据帧的另一个有趣的特性是，我们可以合并、连接它们并添加新值，让我们在 Python Pandas 教程的这一部分看看如何进行这些操作。

*   `merge`函数允许我们按行合并两个 Python Pandas 数据帧:

In[]:
import numpy as np
df1=pd.DataFrame(np.random.randn(5,4), index=['a','b','c','d','e'], columns=['A', 'B', 'C', 'D'])
print(df1)

Out[]:
`


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| a | 1.179924 | -1.512124 | 0.767557 | 0.019265 |
| b | 0.019969 | -1.351649 | 0.665298 | -0.989025 |
| c | 0.351921 | -0.792914 | 0.455174 | 0.170751 |
| d | -0.150499 | 0.151942 | -0.628074 | -0.347300 |
| e | -1.307590 | 0.185759 | 0.175967 | -0.170334 |

df2=pd.DataFrame(np.random.randn(5,4), index=['a','b','c','d','e'], columns=['A', 'B', 'C', 'D'])
print(df2)
`


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| a | 2.030462 | -0.337738 | -0.894440 | -0.757323 |
| b | 0.475807 | 1.350088 | -0.514070 | -0.843963 |
| c | 0.948164 | -0.155052 | -0.618893 | 1.319999 |
| d | 1.433736 | -0.455008 | 1.445698 | -1.051454 |
| e | 0.565345 | 1.802485 | -0.167189 | -0.227519 |

In[]:
df3 = pd.merge(df1, df2)
print(df3)

Out[]:
Empty DataFrame
Columns: [A, B, C, D]
Index: []


*   `append`函数允许我们按行将一个 Python Pandas 数据帧中的行追加到另一个 Python Pandas 数据帧中:

In[]
import numpy as np
df1=pd.DataFrame(np.random.randn(5,4), index=['a','b','c','d','e'], columns=['A', 'B', 'C', 'D'])
print(df1)

  df2=pd.DataFrame(np.random.randn(5,4), index=['a','b','c','d','e'], columns=['A', 'B', 'C', 'D'])
  print(df2)

  df3 = df1.append(df2)
  print(df3)

Out[]


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| a | 1.179924 | -1.512124 | 0.767557 | 0.019265 |
| b | 0.019969 | -1.351649 | 0.665298 | -0.989025 |
| c | 0.351921 | -0.792914 | 0.455174 | 0.170751 |
| d | -0.150499 | 0.151942 | -0.628074 | -0.347300 |
| e | -1.307590 | 0.185759 | 0.175967 | -0.170334 |
| a | 2.030462 | -0.337738 | -0.894440 | -0.757323 |
| b | 0.475807 | 1.350088 | -0.514070 | -0.843963 |
| c | 0.948164 | -0.155052 | -0.618893 | 1.319999 |
| d | 1.433736 | -0.455008 | 1.445698 | -1.051454 |
| e | 0.565345 | 1.802485 | -0.167189 | -0.227519 |

*   `concat`函数允许我们按行或列合并两个 Python Pandas 数据帧:

In[]:
import numpy as np
df1=pd.DataFrame(np.random.randn(5,4), index=['a','b','c','d','e'], columns=['A', 'B', 'C', 'D'])
print(df1)

  df2=pd.DataFrame(np.random.randn(5,4), index=['a','b','c','d','e'], columns=['A', 'B', 'C', 'D'])
  print(df2)

  df3 = pd.concat([df1, df2]) # concat by row
  print(df3)

Out[]:
`


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| a | 1.179924 | -1.512124 | 0.767557 | 0.019265 |
| b | 0.019969 | -1.351649 | 0.665298 | -0.989025 |
| c | 0.351921 | -0.792914 | 0.455174 | 0.170751 |
| d | -0.150499 | 0.151942 | -0.628074 | -0.347300 |
| e | -1.307590 | 0.185759 | 0.175967 | -0.170334 |
| a | 2.030462 | -0.337738 | -0.894440 | -0.757323 |
| b | 0.475807 | 1.350088 | -0.514070 | -0.843963 |
| c | 0.948164 | -0.155052 | -0.618893 | 1.319999 |
| d | 1.433736 | -0.455008 | 1.445698 | -1.051454 |
| e | 0.565345 | 1.802485 | -0.167189 | -0.227519 |

In[]:
df3 = pd.concat([df1, df2], axis=0) # concat by row
print(df3)

Out[]:
`


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| a | 1.179924 | -1.512124 | 0.767557 | 0.019265 |
| b | 0.019969 | -1.351649 | 0.665298 | -0.989025 |
| c | 0.351921 | -0.792914 | 0.455174 | 0.170751 |
| d | -0.150499 | 0.151942 | -0.628074 | -0.347300 |
| e | -1.307590 | 0.185759 | 0.175967 | -0.170334 |
| a | 2.030462 | -0.337738 | -0.894440 | -0.757323 |
| b | 0.475807 | 1.350088 | -0.514070 | -0.843963 |
| c | 0.948164 | -0.155052 | -0.618893 | 1.319999 |
| d | 1.433736 | -0.455008 | 1.445698 | -1.051454 |
| e | 0.565345 | 1.802485 | -0.167189 | -0.227519 |

In[]:
df3 = pd.concat([df1, df2], axis=1) # concat by column
print(df3)

Out[]:


| 
 | A | B | C | D | A | B | C | D |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| a | 1.179924 | -1.512124 | 0.767557 | 0.019265 | 2.030462 | -0.337738 | -0.894440 | -0.757323 |
| b | 0.019969 | -1.351649 | 0.665298 | -0.989025 | 0.475807 | 1.350088 | -0.514070 | -0.843963 |
| c | 0.351921 | -0.792914 | 0.455174 | 0.170751 | 0.948164 | -0.155052 | -0.618893 | 1.319999 |
| d | -0.150499 | 0.151942 | -0.628074 | -0.347300 | 1.433736 | -0.455008 | 1.445698 | -1.051454 |
| e | -1.307590 | 0.185759 | 0.175967 | -0.170334 | 0.565345 | 1.802485 | -0.167189 | -0.227519 |

## Python 熊猫中的时间序列

Python Pandas TimeSeries 包括一组工具，用于处理按时间索引的系列或数据帧。

通常，财务数据系列就是这种类型，因此，了解这些工具将使我们的工作更加轻松。

在 Python 熊猫教程的这一部分，我们将从头开始创建时间序列，然后我们将看到如何操作它们并将它们转换成不同的频率。

### 索引 Python 熊猫时间系列

用`date_range` Panda 的方法，我们可以创建一个有一定频率的时间范围。例如，创建一个从 2018 年 12 月 1 日开始的范围，每小时发生 30 次。

In[]:
rng = pd.date_range('12/1/2018', periods=30, freq='H')
print(rng)

Out[]:
DatetimeIndex(['2018-12-01 00:00:00', '2018-12-01 01:00:00',
'2018-12-01 02:00:00', '2018-12-01 03:00:00',
'2018-12-01 04:00:00', '2018-12-01 05:00:00',
'2018-12-01 06:00:00', '2018-12-01 07:00:00',
'2018-12-01 08:00:00', '2018-12-01 09:00:00',
'2018-12-01 10:00:00', '2018-12-01 11:00:00',
'2018-12-01 12:00:00', '2018-12-01 13:00:00',
'2018-12-01 14:00:00', '2018-12-01 15:00:00',
'2018-12-01 16:00:00', '2018-12-01 17:00:00',
'2018-12-01 18:00:00', '2018-12-01 19:00:00',
'2018-12-01 20:00:00', '2018-12-01 21:00:00',
'2018-12-01 22:00:00', '2018-12-01 23:00:00',
'2018-12-02 00:00:00', '2018-12-02 01:00:00',
'2018-12-02 02:00:00', '2018-12-02 03:00:00',
'2018-12-02 04:00:00', '2018-12-02 05:00:00'],
dtype='datetime64[ns]', freq='H')


我们可以做同样的事情来获得每日频率(或者任何其他的，[参见文档](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.date_range.html?highlight=date_range))。我们可以使用`freq`参数对此进行调整。

In[]:
rng = pd.date_range('12/1/2018', periods=30, freq='D')
print(rng)

Out[]:
DatetimeIndex(['2018-12-01', '2018-12-02', '2018-12-03', '2018-12-04',
'2018-12-05', '2018-12-06', '2018-12-07', '2018-12-08',
'2018-12-09', '2018-12-10', '2018-12-11', '2018-12-12',
'2018-12-13', '2018-12-14', '2018-12-15', '2018-12-16',
'2018-12-17', '2018-12-18', '2018-12-19', '2018-12-20',
'2018-12-21', '2018-12-22', '2018-12-23', '2018-12-24',
'2018-12-25', '2018-12-26', '2018-12-27', '2018-12-28',
'2018-12-29', '2018-12-30'],
dtype='datetime64[ns]', freq='D')


现在，我们在`rng`对象中有了一个`DateTimeIndex`，我们可以用它来创建一个系列或数据帧:

In[]:
ts = pd.DataFrame(np.random.randn(len(rng), 4), index=rng, columns=['A', 'B', 'C', 'D'])
print(ts)

Out[]:
`


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| 2018-12-01 | 0.048603 | 0.968522 | 0.408213 | 0.921774 |
| 2018-12-02 | -2.301373 | -2.310408 | -0.559381 | -0.652291 |
| 2018-12-03 | -2.337844 | 0.329954 | 0.289221 | 0.259132 |
| 2018-12-04 | 1.357521 | 0.969808 | 1.341875 | 0.767797 |
| 2018-12-05 | -1.212355 | -0.077457 | -0.529564 | 0.375572 |
| 2018-12-06 | -0.673065 | 0.527754 | 0.006344 | -0.533316 |
| 2018-12-07 | 0.226145 | 0.235027 | 0.945678 | -1.766167 |
| 2018-12-08 | 1.735185 | -0.604229 | 0.274809 | 0.841128 |

In[]:
ts = pd.Series(np.random.randn(len(rng)), index=rng)
print(ts)

Out[]:
2018-12-01 0.349234
2018-12-02 -1.807753
2018-12-03 0.112777
2018-12-04 0.421516
2018-12-05 -0.992449
2018-12-06 1.254999
2018-12-07 -0.311152
2018-12-08 0.331584
2018-12-09 0.196904
2018-12-10 -1.619186
2018-12-11 0.478510
2018-12-12 -1.036074


有时，我们从互联网资源或 csv 文件中读取数据，我们需要将日期列转换为索引，以便正确处理系列或数据帧。

In[]:
import pandas as pd
df=pd.read_csv('TSLA.csv')
df.tail()

Out[]:


| 
 | 日期 | 打开 | 高的 | 低的 | 关闭 | 卷 | 除息 | 分流比 | adopen | 和高 | AdjLow | 接近的 | AdjVolume | 名字 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| One thousand and seventy-eight | 2013-12-11 | One hundred and forty-one point eight eight | One hundred and forty-three point zero five | One hundred and thirty-nine point four nine | One hundred and thirty-nine point six five | Seven million one hundred and thirty-seven thousand eight hundred | Zero | One | One hundred and forty-one point eight eight | One hundred and forty-three point zero five | One hundred and thirty-nine point four nine | One hundred and thirty-nine point six five | Seven million one hundred and thirty-seven thousand eight hundred | TSLA |
| One thousand and seventy-nine | 2013-12-10 | One hundred and forty point zero five | One hundred and forty-five point eight seven | One hundred and thirty-nine point eight six | One hundred and forty-two point one nine | Ten million seven hundred and forty-eight thousand two hundred | Zero | One | One hundred and forty point zero five | One hundred and forty-five point eight seven | One hundred and thirty-nine point eight six | One hundred and forty-two point one nine | Ten million seven hundred and forty-eight thousand two hundred | TSLA |
| One thousand and eighty | 2013-12-09 | One hundred and thirty-seven | One hundred and forty-one point seven | One hundred and thirty-four point two one | One hundred and forty-one point six | Nine million sixty-one thousand five hundred | Zero | One | One hundred and thirty-seven | One hundred and forty-one point seven | One hundred and thirty-four point two one | One hundred and forty-one point six | Nine million sixty-one thousand five hundred | TSLA |
| One thousand and eighty-one | 2013-12-06 | One hundred and forty-one point five one | One hundred and forty-two point four nine | One hundred and thirty-six point three | One hundred and thirty-seven point three six | Seven million nine hundred and nine thousand six hundred | Zero | One | One hundred and forty-one point five one | One hundred and forty-two point four nine | One hundred and thirty-six point three | One hundred and thirty-seven point three six | Seven million nine hundred and nine thousand six hundred | TSLA |
| One thousand and eighty-two | 2013-12-05 | One hundred and forty point one five | One hundred and forty-three point three five | One hundred and thirty-nine point five | One hundred and forty point four eight | Nine million two hundred and eighty-eight thousand four hundred | Zero | One | One hundred and forty point one five | One hundred and forty-three point three five | One hundred and thirty-nine point five | One hundred and forty point four eight | Nine million two hundred and eighty-eight thousand four hundred | TSLA |

在这里，我们可以看到数字索引和一个日期列，让我们将该列转换为索引，以便及时索引从 csv 文件中读取的数据帧。为此，我们将使用 Python Pandas `set_index`方法

In[]:
df = df.set_index('Date')
df.tail()

Out[]:


| 日期 | 打开 | 高的 | 低的 | 关闭 | 卷 | 除息 | 分流比 | adopen | 和高 | AdjLow | 接近的 | AdjVolume | 名字 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 2013-12-11 | One hundred and forty-one point eight eight | One hundred and forty-three point zero five | One hundred and thirty-nine point four nine | One hundred and thirty-nine point six five | Seven million one hundred and thirty-seven thousand eight hundred | Zero | One | One hundred and forty-one point eight eight | One hundred and forty-three point zero five | One hundred and thirty-nine point four nine | One hundred and thirty-nine point six five | Seven million one hundred and thirty-seven thousand eight hundred | TSLA |
| 2013-12-10 | One hundred and forty point zero five | One hundred and forty-five point eight seven | One hundred and thirty-nine point eight six | One hundred and forty-two point one nine | Ten million seven hundred and forty-eight thousand two hundred | Zero | One | One hundred and forty point zero five | One hundred and forty-five point eight seven | One hundred and thirty-nine point eight six | One hundred and forty-two point one nine | Ten million seven hundred and forty-eight thousand two hundred | TSLA |
| 2013-12-09 | One hundred and thirty-seven | One hundred and forty-one point seven | One hundred and thirty-four point two one | One hundred and forty-one point six | Nine million sixty-one thousand five hundred | Zero | One | One hundred and thirty-seven | One hundred and forty-one point seven | One hundred and thirty-four point two one | One hundred and forty-one point six | Nine million sixty-one thousand five hundred | TSLA |
| 2013-12-06 | One hundred and forty-one point five one | One hundred and forty-two point four nine | One hundred and thirty-six point three | One hundred and thirty-seven point three six | Seven million nine hundred and nine thousand six hundred | Zero | One | One hundred and forty-one point five one | One hundred and forty-two point four nine | One hundred and thirty-six point three | One hundred and thirty-seven point three six | Seven million nine hundred and nine thousand six hundred | TSLA |
| 2013-12-05 | One hundred and forty point one five | One hundred and forty-three point three five | One hundred and thirty-nine point five | One hundred and forty point four eight | Nine million two hundred and eighty-eight thousand four hundred | Zero | One | One hundred and forty point one five | One hundred and forty-three point three five | One hundred and thirty-nine point five | One hundred and forty point four eight | Nine million two hundred and eighty-eight thousand four hundred | TSLA |

现在，我们有熊猫时间系列准备工作。

### 重采样熊猫时间序列

Python Pandas TimeSeries 的一个非常有用的特性是重采样能力，这允许我们将当前频率传递到另一个更高的频率(我们不能传递到更低的频率，因为我们不知道数据)。

可以设想，当我们从一个频率传递到另一个频率时，数据可能会丢失，为此，我们必须使用一些函数来处理每个频率间隔的值，例如，如果我们从每小时一次的频率传递到每天一次的频率，我们必须指定我们想要对每个频率内的数据组做什么，我们可以做均值、求和，我们可以获得最大值或最小值等。

In[]:
rng = pd.date_range('12/1/2018', periods=30, freq='H')
ts = pd.DataFrame(np.random.randn(len(rng), 4), index=rng, columns=['A', 'B', 'C', 'D'])
print(ts)

Out[]:
`


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| 2018-12-01 00:00:00 | 0.048603 | 0.968522 | 0.408213 | 0.921774 |
| 2018-12-01 01:00:00 | -2.301373 | -2.310408 | -0.559381 | -0.652291 |
| 2018-12-01 02:00:00 | -2.337844 | 0.329954 | 0.289221 | 0.259132 |
| 2018-12-01 03:00:00 | 1.357521 | 0.969808 | 1.341875 | 0.767797 |
| 2018-12-01 04:00:00 | -1.212355 | -0.077457 | -0.529564 | 0.375572 |
| 2018-12-01 05:00:00 | -0.673065 | 0.527754 | 0.006344 | -0.533316 |

In[]:
ts = ts.resample("1D").mean()
print(ts)

Out[]:


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| 2018-12-01 | 0.449050 | 0.127412 | -0.154179 | -0.358324 |
| 2018-12-02 | -0.539007 | -0.855894 | 0.000010 | 0.454623 |

### 操纵时间序列

我们可以像现在一样操作 Python Pandas 时间序列，因为它们为我们提供了与 Pandas 系列和 Pandas 数据帧相同的容量。

此外，我们可以轻松处理所有与处理日期相关的工作。例如，获取某个日期的所有数据，获取某个日期范围内的数据，等等。

In[]:
rng = pd.date_range('12/1/2018', periods=30, freq='D')
ts = pd.DataFrame(np.random.randn(len(rng), 4), index=rng, columns=['A', 'B', 'C', 'D'])
print(ts)

Out[]:


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| 2018-12-01 | 0.048603 | 0.968522 | 0.408213 | 0.921774 |
| 2018-12-02 | -2.301373 | -2.310408 | -0.559381 | -0.652291 |
| 2018-12-03 | -2.337844 | 0.329954 | 0.289221 | 0.259132 |
| 2018-12-04 | 1.357521 | 0.969808 | 1.341875 | 0.767797 |
| 2018-12-05 | -1.212355 | -0.077457 | -0.529564 | 0.375572 |
| 2018-12-06 | -0.673065 | 0.527754 | 0.006344 | -0.533316 |

获取特定日期的所有值:

In[]:
ts['2018-12-15':]

Out[]:


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| 2018-12-02 | 0.324689 | -0.413723 | 0.019163 | 0.385233 |
| 2018-12-03 | -2.198937 | 0.536600 | -0.540934 | -0.603858 |
| 2018-12-04 | -1.195148 | 2.191311 | -0.981604 | -0.942440 |
| 2018-12-05 | 0.621298 | -1.435266 | -0.761886 | -1.787730 |
| 2018-12-06 | 0.635679 | 0.683265 | 0.351140 | -1.451903 |

获取日期范围内的所有值:

In[]:
ts['2018-12-15':'2018-12-20']

Out[]:


| 
 | A | B | C | D |
| --- | --- | --- | --- | --- |
| 2018-12-15 | 0.605576 | 0.584369 | -1.520749 | -0.242630 |
| 2018-12-16 | -0.105561 | -0.092124 | 0.385085 | 0.918222 |
| 2018-12-17 | 0.337416 | -1.367549 | 0.738320 | 2.413522 |
| 2018-12-18 | -0.011610 | -0.339228 | -0.218382 | -0.070349 |
| 2018-12-19 | 0.027808 | -0.422975 | -0.622777 | 0.730926 |
| 2018-12-20 | 0.188822 | -1.016637 | 0.470874 | 0.674052 |

## 摘要

让我们总结一下我们在 Python 熊猫教程中学到的几点

*   Python 熊猫数据帧和 Python 熊猫系列是一些最重要的数据结构。这是一个必须掌握流利的处理，因为我们会发现他们在几乎所有的问题，我们处理。
*   Python 熊猫数据帧是由行和列形成的数据结构，并且有一个索引。
*   我们必须把它们想象成数据表(对于只有一列的数组),我们可以通过行或列来选择、过滤、排序、添加和删除元素。
*   ETL 过程中的帮助(提取、转换和加载)
*   我们可以用简单的功能来选择、插入、删除和更新元素。
*   我们可以按行或列进行计算。
*   具有运行矢量化计算的能力。
*   我们可以同时处理几个数据帧。
*   索引和子集化是 Python 熊猫最重要的特性。
*   促进数据的统计探索。
*   它为我们处理 NaN 数据提供了多种选择。
*   另一个额外的优势是读写多种数据格式(CSV、Excel、HDF5 等)的能力。).
*   从外部来源(雅虎、谷歌、Quandl 等)检索数据。)
*   最后，它能够处理日期和时间索引，并为我们提供了一组处理日期的函数。

## 结论

重申一下，这篇文章是从 [Python 基础手册](https://www.quantinsti.com/python-basics-handbook)中摘录的，它是为这两者而创作的；刚开始使用 [Python](https://quantra.quantinsti.com/course/python-for-trading) 的新手，以及有成就的交易者，他们可以在编写策略时使用它作为方便的参考。

请在下面的评论中告诉我们你是否喜欢这篇文章以及其他反馈。

*<small>免责声明:股票市场的所有投资和交易都涉及风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。</small>T11】*

# Python 编程基础

> 原文：<https://blog.quantinsti.com/python-programming/>

由[查尼卡·塔卡](https://www.linkedin.com/in/chainika-bahl-thakar-b32971155/)

Python 无疑是当今世界最流行的编程语言之一。凭借其快速更新的库和易于编码的特性，Python 成功地在快速发展的技术时代占据了一席之地。

你可以参考 [Python 手册](https://www.quantinsti.com/python-basics-handbook)，里面有从基础学习到获得关于熊猫的知识的一切，还有很多直接的例子。有了这本书，你可以在开始实际使用 Python 语言之前学习最相关的信息。这本书也适用于那些想要快速更新 Python 数据分析知识的程序员。最好的部分之一是它是免费的。

让我们找出一些关于 Python 编程的常见问题:

*   [什么是 Python 编程？](#what-is-python-programming)
*   [Python 在交易中的好处](#benefits-of-python-in-trading)
*   [Python 在交易中的应用](#applications-of-python-in-trading)
*   [运行 Python 脚本](#running-of-python-scripts)
*   [什么是语法？](#what-is-syntax)
*   [什么是缩进？](#what-is-indentation)
*   [什么是变量和运算符？](#what-are-variables-and-operators)
*   [条件语句和循环](#conditional-statements-and-loops)
*   [什么是功能？](#what-are-functions)
*   [模块、包和库](#modules-packages-and-libraries)

## 什么是 Python 编程？

Python 是一种重视编码效率和代码可读性的编程语言。Python 使用看起来像书面英语的编码。此外，编码是以单词和句子来完成的，而不是字符。

一个简单的 Python 代码示例如下:

# Heath Berg |美国|利用折扣学习 Python 进行交易

> 原文：<https://blog.quantinsti.com/python-trading-change-career-quantra-success-story-heath-berg/>

如果你已经在 IT 行业工作了 27 年，你会如何追求使用机器学习概念并将其应用于交易的愿望？

Heath 开始自学，从投资股票到通过学习 Python 编程语言稳步提高自己的技能。这个决定在他的旅程中起了关键作用。

怎么会？请继续阅读，了解更多信息。

* * *

同学们，你们好，

我叫希斯·伯格，来自美国德克萨斯州。我已经在 IT 行业工作了 27 年，目前我是一名系统管理员。我投资股票已经有一段时间了，最近，我也开始交易期权。

现在，我对自动化交易和应用[机器学习](/trading-using-machine-learning-python/)概念来自动化我的交易系统非常感兴趣。作为一个概念，我觉得它非常迷人。

> 我的目标是在机器学习领域改变我的职业生涯，特别是量化金融，因为我在其中看到了巨大的机会。

我很幸运地在 Quantra 进行夏季大减价的时候偶然发现了它。我发现这笔交易很有吸引力，于是报名参加了所有与我兴趣相符的课程。我现在已经完成了用于交易的' [Python！关于 Quantra 的课程，我必须说，提供的材料很棒。我真的从这门课中学到了很多。](https://quantra.quantinsti.com/course/python-for-trading)

课程的结构和设计都相当不错。我发现关于熊猫的概念在这门课程中没有被全面涵盖。然而，该团队告诉我，他们计划很快在课程中添加这样的额外材料。

我还尝试了“实时交易”部分的“蓝移”( blue shift )( T1 ),虽然我没有实时使用这个策略，但我通过改变给定代码中的变量和参数做了很多回溯测试。Blueshift 是一个用起来很有趣的工具，肯定和其他平台不一样，但是非常有趣。我喜欢。

作为入门课程，我并没有发现课程中有什么缺失。以那种方式它是相当完整的。我对从课程中学到的信息非常满意，我也很高兴能从其他 Quantra 课程中学到更多。

* * *

我们很高兴您在 Quantra 获得了很好的学习体验。您的话促使我们将产品做得更好。我们现在有 39 门课程，涵盖算法和量化交易的一系列主题。谢谢你。

如今，Quants 和金融技术爱好者也可以像 Heath 一样开始使用 Python 进行交易——编程并在金融市场中使用 Python 进行交易。万事如意！

* * *

*<small>免责声明:本文提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害负责。所有信息均按原样提供。</small>*

# 如何使用 Python 进行交易和投资[网络研讨会]

> 原文：<https://blog.quantinsti.com/python-trading-investment-webinar-29-june-2021/>

* * *

[https://www.youtube.com/embed/fvp4yfyedXE?rel=0](https://www.youtube.com/embed/fvp4yfyedXE?rel=0)

* * *

访问 Python 笔记本[这里](https://quantra.quantinsti.com/startCourseDetails?cid=136&section_no=4&unit_no=2&preview=true#course_type=paid&unit_type=Notebook)。

* * *

## 关于会议

本次网络研讨会旨在从金融市场的角度向您介绍 Python 编程的基础知识。对于希望利用编程和技术将当前交易方法提升到新水平的交易者和投资者来说，这是一个必须参加的会议。

* * *

## 会话大纲

*   Python 环境和库
*   用 python 构建交易策略
*   根据历史数据对策略进行回溯测试
*   在现场市场实施战略
*   分析战略的绩效
*   问与答(Question and Answer)

* * *

## 关于演讲者

![Satyapriya Chaudhari](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/69c1d13dfeacd15b74871ffee5505312.png)

### 萨特雅普里亚·乔德里

###### QuantInsti 的定量分析师

Satyapriya 是 QuantInsti Quantra 内容团队的一名量化分析师。在此之前，她是 GreyAtom 学习团队和 Quattro 风险管理团队的成员。她主要关注的领域是 Python、机器学习和自然语言处理。

* * *

**本次会议于**
2021 年 6 月 29 日星期二
美国东部时间上午 9:30 | IST 时间晚上 7:00 |新加坡时间晚上 9:30 举行

# 用于算法交易的流行 Python 库

> 原文：<https://blog.quantinsti.com/python-trading-library/>

由[沙古塔塔西尔达](https://www.linkedin.com/in/shaguftatahsildar/)&T2】阿波瓦辛格

通过这篇关于“Python 库和平台”的文章，我们将涵盖最流行和最广泛使用的 Python 交易平台和用于量化交易的 Python 交易库。

我们之前也报道过最流行的量化交易回测平台，你可以在这里查看。

Python 是一种免费的开源和跨平台的语言，它有一个丰富的库，可以用于几乎所有可以想象的任务，还有一个专门的研究环境。 [Python](https://quantra.quantinsti.com/course/python-for-trading) 是中低交易频率(即持续时间不少于几秒钟的交易)自动交易的绝佳选择。它有多个 APIs 库，可以链接起来优化它，并允许多种交易想法的更大探索性发展。比如我们可以通过 [Python 股票 API](/historical-market-data-python-api/) 获取历史行情数据。

我们整理了一份由专家撰写的关于 Python 交易的最受欢迎的[博客列表。](/python-trading-top-blogs/)

在这篇博客中，除了流行的 [Python 交易平台](/python-trading-library/#PTP)，我们还将关注流行的 Python 交易库的各种功能，如:

*   [技术分析](#python-trading-library-for-technical-analysis)
*   [数据操作](#python-trading-libraries-for-data-manipulations)
*   [标绘结构](#python-trading-library-for-plotting-structures)
*   [机器学习](#python-trading-libraries-for-machine-learning)
*   [回溯测试](#python-trading-libraries-for-backtesting)
*   [数据收集](#python-trading-libraries-for-data-collection)

![Anchor](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/4765334125b448ec4c4bdf8285a1da72.png "Anchor")

## 用于技术分析的 Python 交易库

### ****TA-Lib**T3】**

[TA-Lib](/install-ta-lib-python/) 或技术分析库是一个开源库，广泛用于使用 RSI(相对强弱指数)、布林线、MACD 等技术指标对金融数据进行技术分析。它不仅适用于 Python，还适用于其他编程语言，如 C/C++、Java、Perl 等。下面是 TA-Lib 中可用的一些函数:BBANDS -用于布林线，AROONOSC -用于 Aroon 振荡器，MACD -用于移动平均线收敛/发散，RSI -用于相对强弱指标。在此阅读更多此类功能[。](https://www.ta-lib.org/function.html)

![Anchor](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/4765334125b448ec4c4bdf8285a1da72.png "Anchor")

## 用于数据操作的 Python 交易库

### ****NumPy**T3】**

NumPy 或数字 Python，提供了大型多维数组和矩阵的强大实现。该库由用于复杂数组处理和这些数组的高级计算的函数组成。这个库的一些数学函数包括三角函数(sin，cos，tan，弧度)，双曲函数(sinh，cosh，tanh)，对数函数(log，logaddexp，log10，log2)等。

### ****熊猫****

Pandas 是一个巨大的 Python 库，用于数据分析和操作，也用于处理数字表或数据框和时间序列，因此，大量用于使用 Python 的算法交易。熊猫可以用于各种功能，包括进口。csv 文件、串行执行算术运算、布尔索引、收集关于数据帧的信息等。

### ****SciPy****

[SciPy](https://www.scipy.org/) ，顾名思义，是一个用于科学计算的开源 Python 库。它与 NumPy 一起用于执行复杂的功能，如数值积分、优化、图像处理等。这是 SciPy 的几个模块，用于执行上述功能:scipy.integrate(用于数值积分)、scipy.signal(用于信号处理)、scipy.fftpack(用于快速傅立叶变换)等。

![Anchor](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/4765334125b448ec4c4bdf8285a1da72.png "Anchor")

## 用于绘制结构的 Python 交易库

### ****【matplot lib】****

这是一个 Python 库，用于绘制 2D 结构，如图形、图表、直方图、散点图等。与用于计算的其他库一起，有必要使用 [matplotlib](/python-matplotlib-tutorial/) 使用图表和图形以图形格式表示数据。matplotlib 的一些功能包括散点图、饼图、堆积图、颜色条等。

![Anchor](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/4765334125b448ec4c4bdf8285a1da72.png "Anchor")

## 用于机器学习的 Python 交易库

### ****Scikit-learn****

它是一个基于 SciPy 库构建的机器学习库，由各种算法组成，包括分类、聚类和回归，可以与其他 Python 库(如 NumPy 和 SciPy)一起用于科学和数值计算。它的一些类和函数是 sklearn.cluster、sklearn.datasets、sklearn.ensemble、sklearn.mixture 等。你可以在这里阅读更多关于图书馆及其功能的信息。

### ****张量流****

[TensorFlow](https://www.tensorflow.org/) 是一个开源软件库，用于高性能数值计算和机器学习应用，如[神经网络](https://quantra.quantinsti.com/course/neural-networks-deep-learning-trading-ernest-chan)。它允许跨各种平台(如 CPU、GPU、TPU 等)轻松部署计算。由于其灵活的架构。点击了解如何安装 TensorFlow GPU [。](/install-tensorflow-gpu/)

### ****Keras****

[Keras](https://keras.io/) 是深度学习库，用于开发神经网络和其他深度学习模型。它可以建立在 TensorFlow、Microsoft Cognitive Toolkit 或 Theano 之上，并专注于模块化和可扩展。它由用于构建神经网络的元素组成，如层、目标、优化器等。在 Python 和 R 上安装 Keras 在这里演示[。该库可用于利用人工神经网络](/installing-keras-python-r/)预测[股票价格的交易中。](/artificial-neural-network-python-using-keras-predicting-stock-price-movement/)

![Anchor](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/4765334125b448ec4c4bdf8285a1da72.png "Anchor")

## 用于回溯测试的 Python 交易库

### ****PyAlgoTrade**T3】**

一个事件驱动的库，专注于回溯测试，支持纸上交易和现场交易。PyAlgoTrade 允许你用历史数据评估你的交易想法，看看它的表现如何。支持[事件驱动的](https://quantra.quantinsti.com/course/event-driven-trading-strategies)回溯测试，访问来自雅虎财经、谷歌财经、NinjaTrader CSVs 的数据以及 CSV 中任何类型的时间序列数据。文档很好，支持 TA-Lib 集成(技术分析库)。它在速度和灵活性方面胜过其他库，然而，最大的缺点是它不支持 Pandas-object 和 Pandas 模块。

### ****滑索****

这是一个事件驱动的系统，支持回溯测试和实时交易。Zipline 有很好的文档记录，有一个很棒的社区，支持交互式经纪人和熊猫集成。然而，与在已编译的应用程序中具有回溯测试功能的商业平台相比，Zipline 速度较慢，并且对于多种产品的交易来说不太方便。

### ****Pybacktest****

Python/pandas 中的矢量化回溯测试框架，旨在使您的回溯测试变得紧凑、简单和快速。它允许用户使用 pandas 的全部功能来指定交易策略，同时隐藏所有交易、股票、业绩统计的手动计算并创建可视化。产生的策略代码在研究和生产环境中都是可用的。目前，只支持单一安全性回溯测试，多重安全性测试可以通过运行单一 sec 回溯测试，然后结合股权来实现。它正在进一步发展，以包括多资产回溯测试能力。

![Anchor](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/4765334125b448ec4c4bdf8285a1da72.png "Anchor")

## 用于数据收集的 Python 交易库

### ****超级金融****

这是一个矢量化系统。一个用于实时金融数据收集、分析和[回溯测试交易策略](https://quantra.quantinsti.com/course/backtesting-trading-strategies)的 python 项目。支持从 Yahoo Finance、Google Finance、HBade 和 Excel 访问数据。

### ****【TWP(用 Python 交易)****

TradingWithPython 或 TWP 库也是一个矢量化系统。它是用于量化交易的函数和类的集合。它包括从雅虎财经、CBOE 和互动经纪人等来源获取数据的工具，以及经常使用的 P&L 基准函数。然而，这个库的文档和课程要花费 395 美元。

### ****使用 Python 在互动券商上交易****

[Interactive Brokers](https://www.interactivebrokers.com/en/home.php) 是一个电子经纪人，它使用包括 Python 在内的各种编程语言提供了一个连接实时市场的交易平台。它为各种电子交易产品提供了全球 100 多个市场目的地，包括股票、期权、期货、外汇、债券、差价合约和基金。IB 不仅有非常有竞争力的佣金和利润率，而且有一个非常简单和用户友好的界面。这里我们将讨论如何使用 Python 连接到 IB。

有几个有趣的 Python 库可以用来连接使用 IB 的实时市场，你需要首先拥有一个 IB 帐户，才能利用这些库进行真实货币交易。

**这是一个易于使用且灵活的 python 库，可用于与交互式经纪人进行交易。它是一个围绕 IB 的 API 的包装器，提供了一个非常简单易用的解决方案，同时隐藏了 IB 的复杂性。为了学习使用 IBridgePy 库，你可以看看这个 T2 的 youtube 视频或者这个 T4 的神奇博客**

### ******IBPy******

**IBPy 是另一个 python 库，可用于使用交互式代理进行交易。关于安装和使用 IBPy 的细节可以在这里找到[。](/ibpy-tutorial-implement-python-interactive-brokers-api/)如上所述，每个库都有自己的优势和劣势。根据策略的要求，您可以在权衡利弊后选择最合适的库。到目前为止，我们已经看了不同的库，现在我们来看 Python 交易平台。**

**![Anchor](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/4765334125b448ec4c4bdf8285a1da72.png "Anchor")**

## **开源 Python 交易平台**

**Python 交易平台提供多种功能，如开发策略代码、[回溯测试](/backtesting/)和提供[市场数据](https://quantra.quantinsti.com/course/getting-market-data)，这就是为什么这些 [Python 交易](https://quantra.quantinsti.com/course/python-trading-basic)平台被量化和算法交易员广泛使用。下面列出了几个流行的免费 python 交易平台，Python 爱好者可以用来进行算法交易。**

### ******蓝移******

**Blueshift 是一个免费的综合性交易和策略开发平台，也支持回溯测试。它有助于人们更专注于策略开发而不是编码，并提供集成的高质量分钟级数据。其基于云的回溯测试引擎使人们能够在 Python 编程环境中开发、测试和分析交易策略。您可以从[这里](https://blueshift.quantinsti.com/)开始使用该平台开发战略。**

****Quantiacs 是一个免费的开源 Python 交易平台，可以用来开发和回测使用 Quantiacs 工具箱的交易想法。Quantiacs 为 49 只期货和标准普尔 500 指数股票提供长达 25 年的免费和干净的金融市场数据。你可以想开发多少策略就开发多少策略，盈利策略可以在 Quantiacs 算法交易竞赛中提交。在 Quantiacs，你可以拥有自己交易想法的知识产权。Quantiacs 投资每场比赛的 3 个最佳策略，如果你的交易策略被选中投资，你将获得一半的绩效费。****

****这些是一些最常用的 Python 库和交易平台。你可以在这里了解一些流行的 Python ide[。但是仍然有很多东西需要探索，包括更多的库和平台，其中大部分你可以通过这门关于量化策略的课程来学习，这门课程不仅包括用于交易的](https://www.dunebook.com/best-python-ide-windows-mac/)[Python](/python-trading/)的基础知识，还包括各种策略，并解释了如何用 Python 实现它们。****

****观看关于“Python 中的自动化交易”的[网络研讨会](/automated-trading-with-python-webinar/)，了解如何用 Python 创建和执行量化策略。****

****您也可以查看这个[教程，使用 IBPy 在 Interactive Brokers API](/ibpy-tutorial-implement-python-interactive-brokers-api/) 中实现 Python。在 IB TWS 上为 quants 和 Python 编码者自动交易。****

******更新******

******我们注意到一些用户在从雅虎和谷歌金融平台下载市场数据时面临挑战。如果您正在寻找市场数据的替代来源，您可以使用 [Quandl](https://www.quandl.com/) 来获得相同的数据。******

******免责声明:本文提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害承担任何责任。所有信息均按原样提供。******

******推荐阅读******

****[Python 交易入门](/getting-started-python-trading)****

****[在 Python 中处理错误和异常](/dealing-python-error-exceptions)****

****[Python 异常:在 Python 中引发和捕获异常](/python-exception)****

****[时间序列分析:Python 简介](/time-series-analysis-introduction-python)****

****[使用 Python 对股票数据的基本操作](/basic-operations-stock-data-using-python)****

# Quantiacs 平台中的 Python 交易策略

> 原文：<https://blog.quantinsti.com/python-trading-strategy-quantiacs-platform/>

![](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/902c6575d91b49c1fb81e16101c8bb9c.png)

由[米林德·帕拉德卡](https://www.linkedin.com/in/milind-paradkar-b37292107/)

算法交易在最近几年有很大的吸引力，希望探索这个利润丰厚的领域的学生、工程毕业生和金融专业人士的数量逐年呈指数增长。

你是想学习量化技术并利用你的交易理念赚钱的人吗？让我们探索 Quantiacs 平台，它允许你创建、运行和实施你的[https://blog.quantinsti.com/python-trading-library/](https://blog.quantinsti.com/python-trading-library/)Python 交易策略。Quantiacs 为成功的量化分析师提供了巨大的赚钱机会。

### **Quantiacs 工具箱**

Quantiacs 工具箱是免费和开源的。Quantiacs 为 49 只期货和标准普尔 500 股票提供长达 25 年的免费数据。该工具包允许用户创建一个交易策略，并用 1990 年的数据进行回溯测试。除了期货数据，Quantiacs 最近还增加了宏观经济数据，这些数据可以与价格时间序列数据结合使用，以改进交易算法。Quantiacs 同时支持 Python 和 Matlab。在本帖中，我们将探索 Python 工具箱，并展示一个使用它的玩具策略。

### **Quantiacs Python 工具箱**

Quantiacs 创建了一个简单而强大的 [Python 框架](http://quantiacs-python-toolbox-documentation.readthedocs.io/en/latest/)，可以用来创建不同类型的算法策略。它提供了定义交易系统设置，如加载市场数据，交易成本，自定义字段，资本等。Python 工具箱的其他特性包括评估交易系统、优化、结果可视化等。让我们在这里探索一下 Python 框架的一些特性。

**加载市场数据:**

Quantiacs 在股票和期货市场都有交易。股票的数据字段如下所示:

![](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/9fde162fae5ae4ec4bb0a9add409f375.png)资料来源:Quantiacs.com

我们可以使用 quantiacsToolbox.loadData 函数在 Python 中加载股票数据。

![](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/97688d05af18e2f77db1bdb23692aff5.png)

可以看出，数据是 Python 字典的形式。让我们检查键值对的数据类型。

![](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/1338c0e7ad9a687e68a89dfa3c0f4bc8.png)

要创建一个 [Python 交易](https://blog.quantinsti.com/python-trading-library/)策略，我们必须操作 numpy 数组，并且要求你对 Python numpy 数组及其支持的无数函数有很好的理解。这里是一些有用功能的[列表](https://docs.scipy.org/doc/numpy/reference/arrays.ndarray.html)。

### **蜡烛高低 Python 策略**

现在让我们采用一个非常简单的蜡烛图高低策略，并尝试使用 Quantiacs 工具箱对其进行编码。一步一步的过程如下所示。

#### **第一步:定义设置**

我们对苹果公司(Apple Inc .)和亚马逊公司(Amazon Inc .)的股票测试了我们的样本策略。回溯测试周期在设置[' begin sample ']和设置['endInSample']变量中定义。我们还定义了回望日、资本和滑点。

![](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/d225ae81181315d6425fffddf4c1465a.png)

#### **第二步:Python 交易策略**

我们保持了简单的策略。在第一步中，我们定义蜡烛线的数量，这些蜡烛线代表先前价格的数量，这些价格将被考虑用于生成买入/卖出信号。然后我们计算最后 n 根蜡烛的价格差。如果所有的价差都是正的，我们做空，预期会出现均值回归行为。如果所有的差价都是负数，我们就做多。

多头头寸由值 1 表示，而空头头寸的值为-1。

![](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/81df511e184c18fd24e18ab304987748.png)

#### **第三步:运行策略**

为了执行我们的策略，我们使用 quantiacsToolbox.runts 命令并指定相应的 Python 文件。

![](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/3c5f72ee7ce39c090a65ef4684fddd7b.png)

#### **第四步:可视化结果**

在执行时，Python 框架会显示一个信息丰富的图表，其中包括市场、选择风险类型的选项、各种性能指标等。

![](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/c674a29b54febac8a9e18b408fa9a7ca.png)

可以看出，Quantiacs Python 框架易于使用，可以用来开发各种交易策略。

### **下一步**

Python 算法交易在 quant finance 社区中获得了牵引力，因为它可以轻松地建立复杂的统计模型，这是因为有足够的科学库可用，如 Pandas、NumPy、PyAlgoTrade、Pybacktest 等。

如果您希望掌握使用 Python 生成交易策略、回溯测试、处理时间序列、生成交易信号、预测分析等艺术，您可以注册我们的 [Python for Trading 课程！](https://quantra.quantinsti.com/course/python-for-trading)

*免责声明:股票市场的所有投资和交易都有风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。*

### **下载 Python 代码**

*   蜡烛线高低策略- Python 代码

# Python 交易十大博客| 2022

> 原文：<https://blog.quantinsti.com/python-trading-top-blogs/>

Python 是加速交易过程的一个关键方面。Python 利用其可行的库和高度功能化的语法来关注回溯测试，并支持纸上交易和现场交易。此外，Python 是一种开源的跨平台编程语言，支持商业用途的免费包。

根据 Emergen Research 的一份报告，“预计 2030 年全球 Python 市场规模将达到 1.006 亿美元，收入 CAGR 将达到 44.8%。”

因此，我们可以看到，在 web 和软件的最终应用中，对 Python 的需求正在上升。与其他编程语言相比，Python 有很大的依赖性，因为它支持实时物联网和边缘计算应用。

Python 在 quant finance 社区获得了牵引力。它使得综合统计模型的开发变得容易。它还使用 Pandas 框架导入财务数据。基于 Python 的解决方案包括分析数据和预测结果的机器学习算法，这些算法有助于开发金融模型和策略。

因此，为了帮助你改进你的交易，我们整理了一份由专家撰写的 Python 交易博客列表。

* * *

## **Python 交易十大博客| 2022**

### [**Python 进行交易:其好处、策略及更多**](/python-trading/)

编程语言 Python 是在 20 世纪 80 年代开发的。虽然它已经有几十年的历史，但是由于它的应用，它已经有了巨大的发展。

而且，在这个算法交易的时代，学习和开发 Python 中的技能已经成为一种必须。为了在算法交易中取得成功，你必须更多地了解 Python 来制定优雅的策略。

因此，在本文中，您将了解到:

*   如何选择编程语言
*   为什么要用 Python 做交易？
*   Python 这些年来的流行
*   Python 在算法交易中的利与弊
*   Python vs. C++ vs. R
*   Python 在金融中的应用
*   如何评价样本交易策略
*   如何在交易中入门 Python
*   还有更多。

### [**Python 中的建筑技术指标**](/build-technical-indicators-in-python/)

技术指标是建立在多个数据集上的数学表达，用来预测市场变化。各种指标有助于评估和确定价格运动的方向。例如，交易者使用动量交易、均值回归策略等指标来分析未来的定价趋势。

您也可以学习如何使用 Python 开发技术指标，正如博客所涵盖的:

*   什么是技术指标？
*   为什么要用 Python 技术指标？
*   交易的技术指标
*   移动平均数
*   布林线
*   相对强度指数
*   资金流动指数
*   平均真实范围
*   力指数
*   易于移动

### [**用 Python 轻松安装 Ta-Lib 的分步指南**](/install-ta-lib-python/)

历史价格和交易量数据在计算技术指标以分析市场趋势时至关重要。指标加在图表上是为了安排进场和出场信号。

想知道如何用 Python 只用几行代码就能计算出技术指标？你想知道如何回测各种金融资产的表现吗？

Ta-Lib 提供了超过 150 个指标，如 ADX、MACD、RSI、布林线以及烛台模式识别。

这个博客包括什么？安装 Ta-Lib 的最简单和可选的方法。

### [**Python 中的层次聚类**](/hierarchical-clustering-python/)

随着原始数据的丰富和分析的需要，无监督学习的概念逐渐流行起来。无监督学习的主要目标是发现未标记数据中隐藏的和令人兴奋的模式。

最常见的无监督学习算法是聚类。聚类分析的应用范围从医学到人脸识别到股票市场分析。在这篇博客中，我们将讨论层次聚类。

根据 [Statista](https://www.statista.com/statistics/871513/worldwide-data-created/) 的一份报告，“全球创建、捕获、复制和消费的数据总量预计将快速增长，到 2020 年将达到 64.2 兆字节。在到 2025 年的未来五年中，全球数据创建预计将增长到 180 多亿字节。”

[Allied Market Research](https://www.alliedmarketresearch.com/financial-analytics-market) 预测，到 2030 年，金融分析市场将达到 198 亿美元。

正如在数据和分析市场的增长中所看到的，需要无监督学习来评估大型数据集。无监督学习提供了在非结构化数据中识别模式的特征。最流行的无监督学习算法之一是聚类。它在股市分析中起着举足轻重的作用。

### [**使用 Python Seaborn** 创建热图](/creating-heatmap-using-python-seaborn/)

该博客提供了一个使用 Seaborn Python 包创建热图的演练，交易员可以用它来跟踪市场。Seaborn 是一个易于使用的库，提供了主要的解决方案。它也是 Python 中一个很酷的数据可视化包，提供了更美观的可视化效果。

本博客涵盖:

*   用于 Python 数据可视化的 Seaborn
*   什么是热图？
*   金融业热图的使用案例
*   创建热图的逐步 Python 代码
    -显示股票单日价格变化百分比
    -显示股票价格变化之间的相关性
*   用于绘制热图的其他 Python 库

### [**用 Python 分析历史数据获得股市洞察！**T3】](/stock-market-data-analysis-python/)

你想获得股票市场的洞察力，并用 Python 分析历史数据吗？

这将使您能够

*   获取股票的历史数据
*   绘制股票市场数据并分析其表现
*   获取基本面、期货和期权数据

正如它所讨论的:

*   如何用 Python 获取股市数据？
*   如何获取不同地域的股市数据？
*   标准普尔 500 证券交易所
*   日内或分钟频率股票数据
*   重新采样股票数据
*   基本数据
*   期货和期权数据
*   股票市场数据可视化和分析

### [**利用 Python 对市场数据进行线性回归，R**](/linear-regression-market-data-python-r/)

这篇文章提供了回归实际财务数据的见解。它还涵盖了使用 Python 和 r 建模关系的方法。它可以帮助精通一种语言或应用程序的读者更深入地了解其他语言的实现。

### [**使用 Python 股票 API 获取历史行情数据**](/historical-market-data-python-api/)

几行代码就可以得到你的数据！这个博客带你了解免费和付费的解决方案。这些解决方案有一个简单的 Python Stock API 包装器，您可以利用它。该博客还涵盖了一些资源，这些资源提供了关于如何通过多种方式获取数据的信息，并附有示例。

博客结构包括

*   使用 Python stock API 免费解决历史数据
*   获得免费历史数据的资源
*   使用 Python stock API 的历史数据付费解决方案
*   获取付费历史数据的资源

### [**Python 中的 XGBoost 介绍**](/xgboost-python/)

XGBoost 是一个开源软件库，它为多种编程语言和操作系统规范了梯度推进框架。这是一个流行的监督学习库，用于对大型数据集进行回归和分类。顶部博客提供了图书馆的详细信息。

该博客提供以下信息:

*   XGBoost 是什么？
*   XGBoost 为什么这么好？
*   XGBoost 功能重要性
*   如何在 anaconda 中安装 XGBoost？
*   Python 中的 xgboost

### [**利用 Python 机器学习预测黄金价格指南**](/gold-price-prediction-using-machine-learning-python/)

有可能预测黄金价格的走向吗？

是的，让我们使用[机器学习回归技术](https://quantra.quantinsti.com/course/trading-with-machine-learning-regression)来预测最重要的贵金属之一黄金的价格。

我们将创建一个[机器学习](https://quantra.quantinsti.com/course/introduction-to-machine-learning-for-trading)线性回归模型，该模型从过去的黄金 ETF (GLD)价格中获取信息，并返回第二天的黄金价格预测。GLD 是 T2 最大的直接投资实物黄金的 ETF T3。在我们使用 Python 中的[机器学习预测黄金价格的旅程中，我们将涉及以下主题。](/trading-using-machine-learning-python/)

* * *

## **一些特别提及**

### [**Python 中的机器学习分类策略**](/machine-learning-classification-strategy-python/)

该博客提供了用 Python 开发分类模型的基础知识和分步指南。

### [**用于算法交易的流行 Python 库**](/python-trading-library/)

通过这篇关于“Python 库和平台”的文章，我们将涵盖最流行和最广泛使用的 Python 交易平台和用于量化交易的 Python 交易库。

我们之前也讨论过最流行的量化交易回测平台。

了解 Algo Trading 中最流行、最广泛使用的 Python 交易平台和库有哪些。这个博客涵盖了 Python 交易平台和几个函数库:

*   技术分析
*   数据操作
*   绘制结构
*   机器学习
*   回溯测试
*   数据收集

### [**Python 中的斐波那契回撤交易策略**](/fibonacci-retracement-trading-strategy-python/)

斐波纳契交易解决方案有助于确定支撑位和阻力位，或确定定价目标。斐波纳契数列对于使用它进行交易的技术分析师来说非常突出。文章简单解释了流行的斐波那契交易策略:回撤以确定支撑位。

### [**在印度市场用 Python 交易**](/trading-with-python-indian-markets/)

Python 是最受欢迎的编程语言之一，因为它具有开源和跨平台的架构。在本文中，了解如何使用 Python 在印度市场进行交易。

### [**Excel 和 Python 中的风险值(VaR)计算**](/calculating-value-at-risk-in-excel-python/)

通过相关示例，学习并运用历史方法和方差-协方差技术在 Excel 和 Python 中计算风险值。

* * *

## **结论**

我们有一个完整的博客、教程、课程等资源库。只为你的学习和发展。Python 的世界非常广阔，因为它是当今时代的一种关键编程语言。

这些只是帮助我们的读者在 2022 年了解更多 Python 的一些博客。我们真的很感谢你在这个博客上的评论，一定要在下面留下你的评论！

* * *

<small>*免责声明:本文提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害负责。所有信息均按原样提供。*</small>

# Python 交易简介:好处、策略等等

> 原文：<https://blog.quantinsti.com/python-trading/>

由 [Viraj Bhagat](https://www.linkedin.com/in/virajbhagat/) 编译

Python，一种由 Guido Van Rossum 在 20 世纪 80 年代后期构思的编程语言，已经见证了巨大的增长，尤其是在最近几年，因为它的易用性、丰富的库和优雅的语法。

*一门编程语言怎么会有‘Python’这样的名字？*

嗯，Python 的创造者 Guido 需要一个简短、独特、有点神秘的名字，因此在观看一部名为“[蒙蒂·Python 的飞行马戏团](https://www.imdb.com/title/tt0063929/)”的喜剧系列片时，他决定使用“Python”。

如果你对 Python 的历史以及什么是 Python 和它的应用很好奇，你可以随时参考 [Python 手册](https://www.quantinsti.com/python-basics-handbook)的第一章，它是你开始 Python 之旅的指南。我们正在走向自动化的世界，因此，总是需要有编程语言经验的人。当谈到[算法交易](https://quantra.quantinsti.com/course/getting-started-with-algorithmic-trading)的世界时，为了让你的交易算法更聪明更快，学习一门编程语言是必要的。

的确，你可以将战略中的编码部分外包给一个有能力的程序员，但当你不得不根据不断变化的市场场景调整你的战略时，这将会很麻烦。

<u>在本文中，我们将介绍以下内容</u>:

*   [选择编程语言](#choosing-a-programming-language)
*   [为什么要用 Python 进行交易？](#why-use-python-for-trading)
*   [Python 这些年的流行程度](#popularity-of-python-over-the-years)
*   [Python 在算法交易中的利与弊](#benefits-and-drawbacks-of-python-in-algorithmic-trading)
*   [Python vs c++ vs R](#python-vs-c-vs-r)
*   [Python 在金融领域的应用](#applications-of-python-in-finance)
*   [用 Python 编码进行交易](#coding-in-python-for-trading)
*   [Python 安装指南](#installation-guide-for-python)
*   [流行的 Python 库又名 Python 包](#popular-python-libraries-aka-python-packages)
*   [在 Python 中处理数据](#working-with-data-in-python)
*   [用 Python 创建样本交易策略和回溯测试](#creating-a-sample-trading-strategy-and-backtesting-in-python)
*   [评估样本交易策略](#evaluating-the-sample-trading-strategy)
*   [如何入门 Python 进行交易](#how-to-get-started-with-python-in-trading)

* * *

## **选择编程语言**

在我们了解 Python 的核心概念及其在金融中的应用以及使用 Python 进行交易之前，让我们了解一下我们应该学习 Python 的原因。

了解流行的编程语言是成为专业算法交易者的基石。随着技术的日新月异，程序员很难学会所有的编程语言。

我们在 QuantInsti 收到的最常见的问题之一是

***“算法交易应该学哪种编程语言？”**T3】*

这个问题的答案是，没有什么比算法交易更好的语言了。在选择编程语言之前，有许多重要的概念需要在整个交易过程中加以考虑:

*   费用
*   表演
*   跳回
*   模块化和
*   其他各种[交易策略](/algorithmic-trading-strategies/)参数

每种编程语言都有其优点和缺点，基于交易系统要求的优点和缺点之间的平衡将影响个人可能更喜欢学习的编程语言的选择。

每个组织基于其业务和文化都有不同的编程语言。

*   你会使用什么样的交易系统？
*   你打算设计一个基于执行的交易系统吗？
*   你需要一个高性能的回溯测试器吗？

基于所有这些问题的答案，你可以决定哪种编程语言最适合算法交易。

* * *

## **为什么要用 Python 进行交易？**

![python xkcd](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/17a858878bdf231b29f3a14ea994d4e9.png)

Python 已经成为最近交易的首选，因为 Python 是开源的，所有的[包](/installing-python-packages/)都可以免费用于商业用途。

Python 已经在 quant finance 社区获得了牵引力。由于有足够的科学库可用，Python 使得构建复杂的统计模型变得很容易。

**一些流行的 Python 库有:**

*   [熊猫](/python-pandas-tutorial/)，
*   [NumPy](/python-numpy-tutorial-installation-arrays-random-sampling/) ，
*   [Matplotlib](/python-numpy-tutorial-installation-arrays-random-sampling/) ，
*   [Scikit-learn](/scikit-learn-tutorial/) ,
*   滑索，
*   [TA-Lib](/install-ta-lib-python/) ，等等。

对 [Python trading](https://quantra.quantinsti.com/course/python-trading-basic) 库的首次更新在开发者社区中是经常发生的事情。外面有无数的社区。

**一些经常光顾的 Python 社区有:**

*   [Python meetups](https://wiki.python.org/moin/LocalUserGroups) -全球约有 1637 个 Python 用户组，分布在 37 个国家的 191 个城市，成员超过 860333 人。
*   Github 上的 200 万个知识库中有超过 130 万个是针对 Python 的
*   有超过 170 万个关于 Python 的问题在 [StackOverflow](https://stackoverflow.com/questions/tagged/python) 上得到回答

我们甚至没有考虑到通过各种门户、团体、平台、论坛等的 Python 的绝大多数本地社区。

量化交易者需要一种脚本语言来构建代码原型。在这方面，

*   Python 在整个交易过程中有着巨大的意义
*   Python 在原型化[量化模型](https://quantra.quantinsti.com/course/quantitative-trading-strategies-models)中得到应用，尤其是在银行和对冲基金的量化交易团队中

> "Python is fast enough for our site and allows us to produce maintainable features in record times, with a minimum of developers,"
> 
> Cuong Do 说，软件架构师，[YouTube.com](http://youtube.com/)。[](https://www.python.org/about/quotes/)【2】

**为什么 quant 交易者更喜欢 Python 进行交易？**

使用 Python 进行交易可以帮助他们:

*   建立他们自己的数据连接器，
*   执行机制，
*   通过[回溯测试](/backtesting/)，
*   [风险管理](/trading-risk-management/)和[订单管理](/automated-trading-order-management-system/)，
*   向前走分析，以及
*   优化测试模块。

[算法交易开发者](/career-developer-algorithmic-trading/)经常困惑于选择开源技术还是商业/专有技术。在决定这一点之前，必须考虑:

*   围绕特定编程语言的社区活动，
*   易于维护，
*   易于安装，
*   语言文档，以及
*   维护成本。

Python 作为一种编程语言之所以流行，部分原因是该领域的一些巨头对它的认可。

这里列出了全球使用 Python 的一些大公司:



> 随着 [#Python](https://twitter.com/hashtag/Python?src=hash&ref_src=twsrc%5Etfw) 的持续快速增长，这里有一份[#使用 Python 的‘十大顶级公司’名单](https://twitter.com/hashtag/list?src=hash&ref_src=twsrc%5Etfw):
> 👉谷歌
> 👉Instagram
> 👉脸书
> 👉Spotify
> 👉Quora
> 👉亚马逊
> 👉网飞
> 👉条纹
> 👉收纳箱
> 👉Reddit
> 
> (来源:TIOBE，Hackernoon)[pic.twitter.com/EP9jDp94Xc](https://t.co/EP9jDp94Xc)
> 
> — QuantInsti (@QuantInsti) [July 11, 2021](https://twitter.com/QuantInsti/status/1414064409698177027?ref_src=twsrc%5Etfw)



# 如何使用 Python 和 Twitter API 获取推文

> 原文：<https://blog.quantinsti.com/python-twitter-api/>

由[乌迪莎·阿洛克](http://www.linkedin.com/in/udisha-alok)

社交媒体是名副其实的信息金矿，也是了解全世界人民集体心理的窗口。无论是政治家、名人、创意艺术家、教授还是学生，每个人似乎都在推特上。

它变得越来越受欢迎，名人的推文影响了数百万粉丝和市场！

因此，Twitter 数据被用于包括交易在内的各种领域的情绪分析。

这篇博客将展示我们如何使用 Twitter API 从 Twitter 获取数据。我们将为此使用 Tweepy 库，并详细探索使用它可以获得的各种类型的数据。这篇博客是由两部分组成的迷你系列的第一部分。

让我们看看我们将在这个博客中涵盖什么。

*   [什么是 Twitter API？](#what-is-twitter-api)
*   [Twitter API v2 访问级别](#twitter-api-v2-access-levels)
*   [访问 Twitter API](#getting-access-to-the-twitter-api)
*   [基本通道与高架通道](#essential-access-vs-elevated-access)
*   [高架通道应用提示](#tips-for-elevated-access-application)
*   [Tweepy 使用 Python 从 Twitter 获取数据](#tweepy-for-fetching-data-from-twitter-using-python)
*   [安装 Tweepy](#installing-tweepy)
*   [API 认证](#api-authentication)
*   [获取用户 id 和屏幕名称](#get-user-id-and-screen-name)
*   [获取用户信息](#get-user-info)
*   [获取追随者数量](#get-follower-count)
*   [从您的时间线获取推文](#get-tweets-from-your-timeline)
*   [获取用户的推文](#get-tweets-by-a-user)
*   [过滤转发和回复](#filtering-retweets-and-replies)
*   [使用分页进行搜索](#search-using-pagination)
*   [获取推文回复](#get-replies-to-a-tweet)
*   [通过标签获取推文](#get-tweets-by-a-hashtag)
*   [通过关键词](#get-tweets-by-a-keyword)获取推文
*   [组合多个查询](#combining-multiple-queries)

* * *

## 什么是 Twitter API？

Twitter API 是 Twitter 提供的官方编程端点。它允许开发者访问 Twitter 上数百万用户每天分享的大量公共数据。

Twitter API 的最新版本是 v2，它是官方的主要 Twitter API。但是 Twitter API v1.1 版还在用。

这两个版本的 API 之间有一些重要的区别。因此，1.1 版中的一些功能可能不适用于 v2。

根据 Twitter 网站的说法，v2 的构建是为了“更好地服务于更广泛的需求，引入了新的功能和端点，并改善了开发人员的体验。”

有关两个版本之间差异的更多信息，请参考此链接。

* * *

## Twitter API v2 访问级别

Twitter API v2 提供了不同的访问级别:基本、高级和学术研究。高架+级也即将到来，根据官方网站。

下图比较了每个访问级别下的一些可用功能。

![Twitter API v2 access levels](https://github.com/OpenDocCN/geekdoc-quant-zh/raw/master/quantinsti/img/6cc9f9fd95ae4702d0f43ba759a2076b.png)

Twitter API v2 access levels: Source



对于本文中出现的一些代码，您需要有提升的访问权限。

* * *

## 访问 Twitter API

要使用 Twitter API v2，您需要:

*   经批准的开发人员帐户。
*   来自位于项目中的开发人员应用程序的密钥和令牌，用于身份验证。

阅读官方指南，了解更多关于 Twitter API 的入门知识。

一旦你注册了开发者账户，你就可以立即获得**基本权限**。需要提升访问权限才能向 Twitter v1.1 版发出请求，并获得 v2 的附加功能。基本访问直接可用，而提升访问必须请求。

* * *

## 基本通道与高架通道

简而言之，基本通道和高架通道的区别如下:

| **序列号** | **基本访问** | **高架通道** |
| one | 不需要申请。 | 需要批准的开发者帐户申请。 |
| Two | 立即可用。 | 一般需要 48-72 小时。但是，审查提升访问权限的申请可能需要两周时间 |
| three | 自由的 | 每月免费访问多达 2M 推文和 3 个应用程序环境 |
| four | 1 个应用程序，1 个项目 | 3 个应用程序，1 个项目 |
| five | 有限的功能 | 更多功能 |

您需要从开发者门户申请提升的访问权限，以访问本博客中讨论的所有代码。这个过程非常简单。

### 高架通道应用技巧

以下是一些我认为有助于提升访问权限申请更快获得批准的有用提示:

1.  在你的应用程序中诚实地说明你的应用程序的目标以及你打算如何使用这些数据。
2.  提供关于您的项目/应用程序的详细信息。
3.  如果您的任何回复需要更多信息，Twitter 将向您发送电子邮件。请尽快坦率地详细回答。
4.  如果你的申请因为没有及时提供所需信息而被拒绝，那么你可以通过回复收件箱中的电子邮件来重新打开该申请。
5.  如果您的应用程序因为其用例违反了 Twitter 政策而被拒绝，您就不能重新申请它。

更多详情，请参考[这些](https://developer.twitter.com/en/support/twitter-api/developer-account)常见问题解答。

一旦您的提升访问权限申请获得批准，您将在您注册的电子邮件地址收到一封电子邮件。

让我们从代码开始吧！

* * *

## 使用 Python 从 Twitter 获取数据的 Tweepy

Tweepy 是一个易于使用的 Python 库，用于访问 Twitter API。它的 API 类提供了对 Twitter API 的 RESTful 方法的访问。这使得它易于理解和学习，成为访问 Twitter API 功能的流行选择。

* * *

## 安装 Tweepy

要使用 pip 从 PyPI 安装 Tweepy，可以使用以下命令:

```py
pip install tweepy

或者，您可以从 Github 存储库安装它:

pip install git+https://github.com/tweepy/tweepy.git

API 认证

当你在 Twitter 上注册开发者账户时，你会得到 API 密匙和密码(这些功能类似于你的应用的用户名和密码)，以及访问令牌和密码(这些代表拥有该应用的用户)。在向 Twitter API 发出请求之前，您将需要这些来验证您自己。

除非重新生成，否则这些密钥和令牌不会过期，并且需要安全地保存，以便您可以为您的代码访问它们，而不会将它们透露给其他人。

为此，我们将创建一个配置文件来保存这些凭据。然后，我们将在代码中从配置文件中读取这些值。

创建配置文件

  1. 打开记事本(或任何基本的文本编辑器)，并创建以下格式的文件:
[twitter]
api_key = XXXXXXXXXXXXXXXXXXXXXXXXX
api_key_secret = XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
access_token = XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
access_token_secret = XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

2.现在，用“config.ini”这个名称保存这个文件。

从配置文件中读取凭据

我们现在将使用 configparser 库从配置文件中读取凭据的值。

利用二次判别分析优化日内动量策略

原文：https://blog.quantinsti.com/quadratic-discriminant-analysis-optimize-intraday-momentum-strategy/

拉马克·科尔曼

在本帖中，我们将创建一个日内动量策略，并使用 QDA 作为优化策略的手段。我们将首先回顾线性判别分析(LDA)及其与 QDA 的关系，了解 QDA，以及何时可以用这种技术代替线性判别分析。然后，我们将使用埃米尼标准普尔 500 期货的数据创建我们的日内动量策略，并应用我们的 QDA 分析来改进我们的交易策略。

我们开始吧！

线性判别分析综述

回想一下，使用机器学习技术的目的是为了让我们能够从数据中做出更好的推断和预测。因此，机器学习的目的类似于实现量化交易工作流程的目的。在定量交易中，我们的目标是消除认知偏差，最终将我们的决策建立在合理的证据或逻辑上。换句话说，我们的目标是用量化交易提供的客观性来取代手工交易固有的主观性。机器学习是实现这一目标的手段。

分类是机器学习问题的一种类型。在一个标准分类问题中，我们有一些【y】或包含 k 水平或可能类别的响应。我们可以使用定量或数字、定性或分类，或者两种数据类型的混合作为我们的或特征来预测我们的数据的类别。

在交易环境中，分类问题的一个例子是试图预测下一个价格的方向。在回归设置中，我们将尝试构建一个模型，使我们能够预测实际价格或数字响应。所以回归问题处理数字预测，分类处理分类预测。

当我们实现机器学习算法时，我们对【f(X)进行近似，这是一个表示 X 或我们的预测器和 y (我们的响应)之间关系的方程。参数模型为我们提供的优势是专注于估计一个方程的特定系数，而不是估计整个方程。

这意味着，我们可以对我们的数据做出一些假设，并基于现有的方程构建我们的模型，并求解该方程的系数，而不是试图构建一个完整的方程来表示我们的输入和输出之间的关系。这种模型有优点也有缺点，我们不会深入探讨，但本质上，为了有效地提供预测，模型需要反映或“模拟”现实中的数据。模型具有固有的假设，如果这些假设与现实不一致，模型的准确性或预测能力就会很低。

从它的名字，你可能已经猜到 LDA 假设线性。

在 LDA 中，我们从我们的观察可以落入的 k 类开始。该模型为每个 k 类创建概率分布。与直接估计观察值在特定类别中的概率的逻辑回归不同，LDA 使用 Bayes 定理并间接地估计这个后验概率。

例如，从代数上回忆一下，直线的方程是 y=mx+b 。

有了这个等式，我们可以简单地通过估计 m 和 b 来拟合我们的数据，其中 m 是给定x中一个单位变化的 y 的斜率或导数(即变化率),而是截距这个等式允许我们，给定一些 x 值，来估计系数【m】和【b】，并对【y】进行预测。******

此过程类似于实现参数模型的过程。我们有一个关于数据结构的假设，通过我们的线性方程来说明，因此我们可以简单地估计我们的系数来进行预测。

LDA 的等式如下:

LDA equation

在这个等式中，我们寻求估计或每个 k 、 π k ，或k类和σ的先验概率，或每个类之间的公共协方差矩阵一旦我们有了这些系数，我们就可以把它们代入我们的方程进行预测。********

我们将在下一篇题为“使用线性判别分析进行量化投资组合管理”的文章中介绍更多关于 LDA 的内容这个帖子将很快上线。

什么是二次判别分析？

二次判别分析是另一种机器学习分类技术。像 LDA 一样，它试图估计一些系数，将这些系数代入一个方程，作为进行预测的手段。实际上，LDA 和 QDA 非常相似。两者都假设 k 类可以从高斯分布中提取。QDA 也像 LDA 一样，使用 Baye 定理来估计方程的参数。QDA 的方程式如下:

QDA 1

等于:

QDA 2

因此我们可以看到，我们的 QDA 方程看起来与我们的 LDA 方程有些相似，只是在 LDA 中我们估计kT5、 π k 和 σ 2 ，但在 QDA 我们估计μk********

在 LDA 中，我们假设每个kthT5】类有一个共享协方差矩阵， σ 2 。但是在 QDA，这个假设已经改变了，我们现在假设每个k类都有自己的协方差矩阵， ∑ k 。********

好了，现在你可能在想，如果 LDA 和 QDA 有相似之处，我们为什么要用 QDA。难道我们不能只关注 LDA 吗？因为很明显，QDA 更复杂一些，并且包含了矩阵乘法。

虽然 LDA 和 QDA 很相似，但也存在应该使用 QDA 的情况，并且可能优于 LDA，反之亦然。例如，LDA 假设 k 个类共享一个协方差矩阵。如果这种假设是无效的，那么 QDA 将优于 LDA。模型的另一个考虑是它们的灵活性。模型的灵活性可以直接转化为偏差-方差的权衡。模型越灵活，就越有可能过度拟合数据，并具有低偏差但高方差。相比之下，模型越不灵活，它就越有可能具有高偏差但低方差，因此并不真正类似于真实的总体。

伦敦发展署远没有 QDA 灵活。如果公共协方差矩阵的假设不正确，则 LDA 将具有高偏差，或者不代表现实。如果这个假设是正确的，那么使用 LDA 进行分类可能比使用 QDA 更好。

此外，特征的数量在模型选择中起着重要的作用。如果有很多预测器，使用 QDA 将比 LDA 的计算效率更低。这是因为在 QDA，你有更多的参数要估计，而且自然地，这在某种程度上是基于预测因子的数量而增长的。如果有很多训练观察，QDA 可能是更好的选择。

日内动量策略开发

好吧。现在我们已经回顾了 LDA 和 QDA，让我们为发展我们的日内动量策略制定一个框架。我们将使用 eMini 标准普尔 500 的日内数据，并将 RSI 作为我们的动量指标。我们的目标是构建我们的策略，评估其性能，然后通过使用二次判别分析来改进我们的策略的性能。

让我们导入一些我们常用的库。

*****#data analysis and manipulation
import numpy as np
import pandas as pd
#data visualization
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style('whitegrid')*****

现在我们已经导入了初始库，让我们导入数据。我们将使用 pandas 读取 csv 文件格式的数据。

*****#initializing our data variable as our eMini data
data=pd.read_csv('ESPostData.csv')*****

现在我们有了数据，让我们对它进行一些探索性的数据分析。我们将从使用信息和描述方法以及检查数据头开始。

*****data.info()*****

*****<class 'pandas.core.frame.DataFrame'>
RangeIndex: 28027 entries, 0 to 28026
Data columns (total 10 columns):
Date            28027 non-null object
Time            28027 non-null object
Open            28027 non-null float64
High            28027 non-null float64
Low             28027 non-null float64
Close           28027 non-null float64
Volume          28027 non-null int64
NumberOfTrades  28027 non-null int64
BidVolume       28027 non-null int64
AskVolume       28027 non-null int64
dtypes: float64(4), int64(4), object(2)
memory usage: 2.1+ MB*****

通过应用这种方法，我们可以看到数据帧中的数据类型以及列。现在让我们对我们的数据调用所描述的方法。

*****data.describe()*****

Statistical information

这个方法给了我们一些关于数据的统计信息。我们现在可以检查数据的头部。

*****data.head()*****

Data Head

我们将创建一个基于动力的战略。我们可以看到每隔 3 分钟就有一次数据。买入和卖出的交易量可以提供一些短期动力的信息。让我们创建一个 delta 柱，我们的出价量减去我们的要价量，并将其与收盘价进行比较，看看是否有一些关系。我们将首先复制我们的数据，然后添加我们的 delta 列。

*****#making copy of our data
es=data.copy()
#creating delta column
es['Delta']=es[' BidVolume']-es[' AskVolume']*****

现在让我们重新检查我们的数据头部，并创建一个回归图。

*****es.head()*****

Recheck head of data

*****#creating regression plot
sns.lmplot('Delta',' Close',data=es)
plt.title('ES Regression Delta to Close')*****

*****<matplotlib.text.Text at 0x16b7bae3080>*****

ES Regression Delta to Close

现在我们已经了解了我们的 delta 和收盘价之间的关系，让我们画一个 delta 的分布图。

*****#creating distribution of delta
sns.distplot(es['Delta'])
plt.title('ES Delta Distribution')*****

*****<matplotlib.text.Text at 0x16b7bbb3550>*****

ES Delta Distribution

现在，我们将向数据中添加一个范围列，并查看每个条形的范围与增量之间的关系。

*****#adding our range column
es['Range']=es[' High']-es[' Low']*****

*****#rechecking the head of our data
es.head()*****

Add range column

现在我们可以创建一个 delta 和数据范围的散点图。

*****sns.jointplot(es['Delta'], es['Range'])*****

*****<seaborn.axisgrid.JointGrid at 0x16b7ee09470>*****

Scatter Plot

现在我们来看看每根棒线交易次数的分布。

*****#creating number of trades distribution
sns.distplot(es[' NumberOfTrades'],bins=100)*****

*****<matplotlib.axes._subplots.AxesSubplot at 0x16b7ef2bc18>*****

Distribution of Trades

现在我们已经从探索性数据分析中获得了一些数据，我们准备使用 RSI 指标创建我们的日内动量策略。我们将把我们的策略包装在一个类中，该类允许我们创建策略的不同实例，而不必重写相同的逻辑。

*****class rsi_strategy(object):

 def __init__(self,data,n,data_name,start,end):

   self.data=data #the dataframe
   self.n=n #the moving average
   self.data_name=data_name #the name that will appear on plots
   self.start=start #the beginning date of the sample period
   self.end=end #the ending date of the sample period

def generate_signals(self):

   delta=self.data[' Close'].diff()
   dUp,dDown=delta.copy(),delta.copy()
   dUp[dUp<0]=0
   dDown[dDown>0]=0
   RolUp=dUp.rolling(self.n).mean()
   RolDown=dDown.rolling(self.n).mean()

   #assigning indicator to the dataframe
   self.data['RSI']=np.where(RolDown!=0, RolUp/RolDown,1)
   self.data['RSI_Slow']=self.data['RSI'].rolling(self.n).mean()

   #creating signals
   self.data=self.data.assign(Signal=pd.Series(np.zeros(len(self.data))).values)
   self.data.loc[self.data['RSI']<self.data['RSI_Slow'],'Signal']=1
   self.data.loc[self.data['RSI']>self.data['RSI_Slow'], 'Signal']=-1

   return

def plot_performance(self,allocation):
    #intializing a variable for initial allocation
    #to be used to create equity curve
    self.allocation=allocation

    #creating returns and portfolio value series
    self.data['Return']=np.log(self.data[' Close']/self.data[' Close'].shift(1))
    self.data['S_Return']=self.data['Signal'].shift(1)*self.data['Return']
    self.data['Market_Return']=self.data['Return'].expanding().sum()
    self.data['Strategy_Return']=self.data['S_Return'].expanding().sum()
    self.data['Portfolio Value']=((self.data['Strategy_Return']+1)*self.allocation)

    #creating metrics
    self.data['Wins']=np.where(self.data['S_Return'] > 0,1,0)
    self.data['Losses']=np.where(self.data['S_Return']<0,1,0)
    self.data['Total Wins']=self.data['Wins'].sum()
    self.data['Total Losses']=self.data['Losses'].sum()
    self.data['Total Trades']=self.data['Total Wins'][0]+self.data['Total Losses'][0]
    self.data['Hit Ratio']=round(self.data['Total Wins']/self.data['Total Losses'],2)
    self.data['Win Pct']=round(self.data['Total Wins']/self.data['Total Trades'],2)
    self.data['Loss Pct']=round(self.data['Total Losses']/self.data['Total Trades'],2)

    #Plotting the Performance of the RSI Strategy

    plt.plot(self.data['Market_Return'],color='black', label='Market Returns')
    plt.plot(self.data['Strategy_Return'],color='blue', label= 'Strategy Returns')
    plt.title('%s RSI Strategy Backtest'%(self.data_name))
    plt.legend(loc=0)
    plt.tight_layout()
    plt.show()

    plt.plot(self.data['Portfolio Value'])
    plt.title('%s Portfolio Value'%(self.data_name))
    plt.show()*****

好吧。现在让我们试试我们的 rsi_strategy 类。

*****#creating an instance of our strategy class
strat1=rsi_strategy(es,10,'ES',es['Date'][0],es['Date'].iloc[-1])*****

既然我们有了 RSI 策略的实例，我们现在可以调用生成信号和绘制性能方法来查看我们的策略的执行情况。

*****#generating signals
strat1.generate_signals()*****

*****#plotting performance of our strat1 strategy
#passing in an allocation amount of $10,000
strat1.plot_performance(10000)*****

ES RSI Strategy Backtest

ES Portfolio Value

现在我们已经构建了策略，我们可以使用编码到策略类中的功能来检查它的一些指标。我们将检查我们的命中率、胜率和失败率。

*****#checking our Hit Ratio
strat1.data['Hit Ratio'][0]*****

*****0.93000000000000005*****

这个命中率告诉我们，我们的策略目前的胜败比不到 1 比 1。现在让我们检查我们的赢输百分比。

*****#checking our win percentage
print('Strategy Win Percentage')
strat1.data['Win Pct'][0]*****

*****Strategy Win Percentage
0.47999999999999998*****

*****#checking our loss percentage
print('Strategy Loss Percentage')
strat1.data['Loss Pct'][0]*****

*****Strategy Loss Percentage
0.52000000000000002*****

我们还可以检查我们的总盈亏数，以及我们的策略的总交易数。

*****#checking total number of wins
strat1.data['Total Wins'][0]*****

*****10818*****

*****#checking total number of losses
strat1.data['Total Losses'][0]*****

*****11613*****

*****#checking total number of trades
strat1.data['Total Trades'][0]*****

*****22431*****

在这一点上，我们已经对我们的数据进行了探索性的数据分析，创建了我们的日内动量策略，并查看了我们策略的指标。我们的策略目前的命中率不到 1。我们的胜率约为 48%，亏损率为 52%。从表面上看，这并不令人印象深刻。

我们如何改进我们的战略，以便我们能够从中获利？

即使我们输的比赢的稍微多一点，如果我们能有效地消除一些亏损的交易，我们就能反过来重新调整我们的盈亏百分比和命中率。换句话说，我们的成功交易不是问题。实际上，赢得 48%的时间比赢得少于 48%的金额要好。问题是，考虑到我们总交易的分布，我们赢的不够多。如果我们几乎消除了所有亏损的交易，会怎么样？我们的交易会少很多，但我们的胜率会飙升，这样我们就可以交易策略获利。

正确识别问题或任务是任何机器学习应用程序的关键技能。我们将利用 QDA 来改进我们现有的战略。我们的目标是能够预测我们的策略何时可能在亏损交易发生之前进行亏损交易，以便我们能够消除亏损交易，从而重新平衡我们的盈亏百分比。听起来很有趣！我们开始吧！

使用 QDA 优化日内动量策略

现在我们将使用 QDA 作为改进我们日内动量策略的一种手段。我们先从 sklearn 导入必要的库开始。

*****from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
from sklearn.metrics import confusion_matrix, classification_report*****

我们需要一种方法来确定我们什么时候可能进行亏损交易。嗯……我们给数据添加一个分类返回列怎么样。然后我们可以做一点特征工程并使用我们的 QDA 分类器来预测分类返回值。一旦我们完成了这个，我们就可以通过把我们的预测反馈给我们的策略来测试我们的想法，看看这是否能提高我们策略的性能。

我们将从复制我们的战略数据框架开始。回想一下，这是我们构建战略的初始实施时创建的数据框架。

*****df=strat1.data*****

让我们检查一下数据帧的头部。

*****df.head()*****

Head of dataframe

现在让我们添加我们的分类返回列。

*****#adding column to hold the direction of returns
df['Return Direction']=np.where(df['Strategy_Return']>0,'Up',np.where(df['Strategy_Return']<0,'Down',"Flat"))*****

让我们在返回方向列上调用我们的 head 和 tail 方法。

*****df['Return Direction'].head()*****

*****0 Flat
1 Flat
2 Flat
3 Flat
4 Flat
Name: Return Direction, dtype: object*****

*****df['Return Direction'].tail()*****

*****28022 Down
28023 Down
28024 Down
28025 Down
28026 Down
Name: Return Direction, dtype: object*****

现在我们已经添加了返回方向列，我们可以开始考虑我们应该使用什么特征来预测我们的策略亏损的概率。我们可以利用标的的波动性，因为它应该对我们的策略有一些影响。我们还可以使用不同的波动滞后来捕捉动量的演变。我们也可以使用我们的 RSI 指标。好吧。让我们把这些加到我们的数据框里。

你可能想知道为什么我们不用我们的信号发生器。我们希望以一种可以应用于任何市场环境的方式来训练我们的模型。在任何给定的时间，在各种市场条件下，我们的多头和空头可能会有不同的分布。例如，如果我们在牛市中，我们更有可能得到做多信号而不是做空信号。与我们的短期交易相比，我们的长期交易也更有可能获得更大程度的盈利。如果我们训练我们的模型来预测我们的信号发生器在此期间的亏损交易，它会将长信号与收益递增相关联，将短信号与收益递减相关联。虽然目前这可能是真的，但将来当我们进入熊市时，这个模型会有很大的偏差，不能预测我们亏损的交易。

*****#adding our features
#creating volatility
strat1.data['Vol']=strat1.data[' Close'].rolling(window=5).std()
#creating lags of volatility
strat1.data['Vol Lag 3']=strat1.data['Vol'].shift(3)
strat1.data['Vol Lag 4']=strat1.data['Vol'].shift(4)
strat1.data['Vol Lag 5']=strat1.data['Vol'].shift(5)*****

好吧，让我们暂停一下，确保我们明白这里发生了什么。我们首先对日内数据进行了一些探索性的数据分析。我们的目标是使用 RSI 指标创建一个日内交易策略。我们创建了一个类，允许我们创建动量策略的实例。我们对我们战略的表现并不感到兴奋，但我们确实认识到它有一些潜力。

我们的策略目前的赢亏比不到 1。它目前赢了 48%的时间，输了 52%的时间。我们的前提是，如果我们可以消除一些亏损的交易，从而减少一些交易，我们就可以将我们的策略盈利的可能性转变为对我们有利。事实上，我们只赢了 48%的时间不是真正的问题。如果我们只进行这些交易，同时将总交易量减半，我们就有了一个完美的(理论上的)策略。换句话说，我们需要一种定量的方法来改进我们的策略，以便它可以实际用于生产。

为了实现我们的目标，我们必须能够预测何时我们的策略可能会进行可能会亏损的交易。因此，我们创建了回报方向栏来跟踪我们的交易是赢了还是输了。我们需要可以在我们的训练模型中使用的特征，这些特征可以提供一些亏损交易概率的指示。我们选择了波动性滞后和我们的 RSI，在上面的代码块中，我们添加了波动性及其滞后。请注意，我们是在“ strat1.data ”而不是“ es ”数据帧上做的。strat1.data 是我们在制作动量策略的 strat1 实例时创建的数据框架。我们简单地将在我们的类中创建的“数据”数据帧命名为 dataframe，并将我们的特征存储在其中。这样做的目的是因为我们正在优化保持我们回报的战略 1 动量策略。回想一下，我们的 es 数据框架只保存我们传递到策略中的数据。

一旦我们创建了 QDA 模型，我们可以将其预测存储在 es 数据框架的副本中，然后创建第二个动量策略实例并比较结果。我们需要稍微改变一下我们的类，这样它就可以在交易之前读取我们的预测。所以本质上，只有当我们的 QDA 模型预测交易不太可能是亏损交易时，我们的策略才会交易。

现在我们有了我们的特性，我们可以初始化我们的 X 和 y 变量，并进行我们的训练测试分割。让我们复制我们的 strat1.data 数据帧并检查它的头。

*****#copying our strategy dataframe
df=strat1.data.copy()*****

*****#checking the head of our df dataframe
df.head()*****

Check Head of dataframe

为了确保我们使用所有适当的列，让我们在 dataframe 上调用 info 方法。

*****df.info()*****

*****<class 'pandas.core.frame.DataFrame'>
RangeIndex: 28027 entries, 0 to 28026
Data columns (total 33 columns):
Date              28027 non-null object
 Time             28027 non-null object
 Open             28027 non-null float64
 High             28027 non-null float64
 Low              28027 non-null float64
 Close            28027 non-null float64
 Volume           28027 non-null int64
 NumberOfTrades   28027 non-null int64
 BidVolume        28027 non-null int64
 AskVolume        28027 non-null int64
Delta             28027 non-null int64
Range             28027 non-null float64
RSI               28017 non-null float64
RSI_Slow          28008 non-null float64
Signal            28027 non-null float64
Return            28026 non-null float64
S_Return          28026 non-null float64
Market_Return     28026 non-null float64
Strategy_Return   28026 non-null float64
Portfolio Value   28026 non-null float64
Wins              28027 non-null int32
Losses            28027 non-null int32
Total Wins        28027 non-null int64
Total Losses      28027 non-null int64
Total Trades      28027 non-null int64
Hit Ratio         28027 non-null float64
Win Pct           28027 non-null float64
Loss Pct          28027 non-null float64
Return Direction  28027 non-null object
Vol               28023 non-null float64
Vol Lag 3         28020 non-null float64
Vol Lag 4         28019 non-null float64
Vol Lag 5         28018 non-null float64
dtypes: float64(20), int32(2), int64(8), object(3)
memory usage: 6.8+ MB*****

现在，我们可以清楚地看到我们所有的列。我们的 X 或特征将是我们的波动和 RSI 的滞后，我们的 y 或响应将是我们的回报方向柱。我们现在可以初始化变量了。

*****#initializing features
X=df[['Vol Lag 3','Vol Lag 4','Vol Lag 5', 'RSI']]*****

*****#initialing our response
y=df['Return Direction']*****

*****#checking the head of our features
X.head()*****

Check Head of Features

我们现在可以将数据分成训练集和测试集。我们将从 sklearn 导入训练测试分割来做这件事。

*****from sklearn.model_selection import train_test_split*****

现在我们准备使用我们的训练测试分割方法。

*****#initializing training and testing variables
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.2)*****

既然我们已经将我们的数据分割成 80/20 的训练测试分割，我们可以初始化我们的 QDA 模型并使其适合我们的数据。

*****model=QuadraticDiscriminantAnalysis()*****

在拟合训练数据之前，我们需要填充空值。

*****#fitting model to our training data
#and filling null values with 0
model.fit(X_train.fillna(0),y_train)*****

*****QuadraticDiscriminantAnalysis(priors=None, reg_param=0.0,
     store_covariances=False, tol=0.0001)*****

现在我们已经拟合了我们的模型，我们可以通过传递我们的 X 测试数据来使用它进行预测。这些数据是我们的模型还没有看到的特征。然后，我们可以将我们的模型做出的预测与 y 测试数据，或者我们反应的实际值进行比较。

*****#creating predictions
predictions=model.predict(X_test.fillna(0))*****

现在，我们将使用混淆矩阵和分类报告来评估我们的模型表现如何。

*****#initializing confusion matrix
print('Confusion Matrix:')
print(confusion_matrix(y_test,predictions))*****

*****Confusion Matrix:
[[4902 6 242]
[ 2 0 0]
[ 399 0 55]]*****

*****#initializing classification report
print('Classification Report')
print(classification_report(y_test,predictions))*****

*****Classification Report
      precision recall f1-score support
Down     0.92    0.95    0.94    5150
Flat     0.00    0.00    0.00       2
Up       0.19    0.12    0.15     454
avg / total 0.86 0.88 0.87 5606*****

哇！我们的模型能够以 92%的准确率预测亏损交易。

我们现在可以将我们的预测添加回我们的 es 数据帧，然后将其传递回我们的 rsi_strategy 类，以创建一个 strat2 实例，并将我们的指标与我们的 strat1 指标进行比较。

在将我们的预测添加到我们的 es 数据框架之前，让我们重新检查一下。我们将在数据帧上调用 head 方法。

*****#rechecking the head of our es data
es.head()*****

Rechecking Head of ES Data

现在让我们把我们的预测添加到我们的 es 数据框架中。

回想一下，为了构建我们的 QDA 模型，我们必须进行 80-20 列车测试划分。这意味着我们在 80%的 es 数据上训练我们的模型，并在 20%上测试它。这也意味着我们只对 20%的数据进行了预测，因此我们预测的长度与 es 数据帧的长度不匹配。

假设我们从分类报告和混淆矩阵中知道我们的模型是有效的，我们要做的是使我们的模型适合我们所有的 es 数据，这样我们就可以得到对另外 80%数据的预测，并能够将它们添加到我们的 es 数据框架中。

我们将初始化第二个预测变量，并将整个 X 传递给我们的模型。

*****#initializing second predictions variable for es dataframe
predictions_2=model.predict(X.fillna(0))*****

现在，我们准备将我们的预测添加到 es 数据框架中，以便将其传递到我们的 rsi_strategy 中。

*****#adding our QDA model's predictions to our es dataframe
es['Predictions']=predictions_2*****

好了，现在我们已经把我们的预测存储在我们的 es 数据框架中了。现在我们可以重新调整我们的策略，这样如果我们预测“下跌”，或者换句话说，如果我们的模型预测亏损，我们就不交易。让我们将这个额外的逻辑添加到我们的类中。

*****class optimized_rsi(object):

def __init__(self,data,n,data_name,start,end):

    self.data=data #the dataframe
    self.n=n #the moving average
    self.data_name=data_name #the name that will appear on plots
    self.start=start #the beginning date of the sample period
    self.end=end #the ending date of the sample period

def generate_signals(self):

    delta=self.data[' Close'].diff()
    dUp,dDown=delta.copy(),delta.copy()
    dUp[dUp<0]=0 dDown[dDown>0]=0
    RolUp=dUp.rolling(self.n).mean()
    RolDown=dDown.rolling(self.n).mean()

    #assigning indicator to the dataframe
    self.data['RSI']=np.where(RolDown!=0, RolUp/RolDown,1)
    self.data['RSI_Slow']=self.data['RSI'].rolling(self.n).mean()

    #creating signals;
    #altering the signal generator by going through our predictions
    #and reinitializing signals to 0 whose prediction is down
    self.data=self.data.assign(Signal=pd.Series(np.zeros(len(self.data))).values)
    self.data['QDA Signal']=np.zeros(len(self.data))

    self.data.loc[self.data['RSI']<self.data['RSI_Slow'],'Signal']=1 self.data.loc[self.data['RSI']>self.data['RSI_Slow'], 'Signal']=-1

    self.data['QDA Signal']=np.where(self.data['Predictions']=="Down",0,self.data['Signal'])

    return

def plot_performance(self,allocation):
    #intializing a variable for initial allocation
    #to be used to create equity curve
    self.allocation=allocation

    #creating returns and portfolio value series
    self.data['Return']=np.log(self.data[' Close']/self.data[' Close'].shift(1))
    #using our signal 2 column to calcuate returns instead of signal 1 column
    self.data['S_Return']=self.data['QDA Signal'].shift(1)*self.data['Return']
    self.data['Market_Return']=self.data['Return'].expanding().sum()
    self.data['Strategy_Return']=self.data['S_Return'].expanding().sum()
    self.data['Portfolio Value']=((self.data['Strategy_Return']+1)*self.allocation)

    #creating metrics
    self.data['Wins']=np.where(self.data['S_Return'] > 0,1,0)
    self.data['Losses']=np.where(self.data['S_Return']<0,1,0)
    self.data['Total Wins']=self.data['Wins'].sum()
    self.data['Total Losses']=self.data['Losses'].sum()
    self.data['Total Trades']=self.data['Total Wins'][0]+self.data['Total Losses'][0]
    self.data['Hit Ratio']=round(self.data['Total Wins']/self.data['Total Losses'],2)
    self.data['Win Pct']=round(self.data['Total Wins']/self.data['Total Trades'],2)
    self.data['Loss Pct']=round(self.data['Total Losses']/self.data['Total Trades'],2)

    #Plotting the Performance of the RSI Strategy

    plt.plot(self.data['Market_Return'],color='black', label='Market Returns')
    plt.plot(self.data['Strategy_Return'],color='blue', label= 'Strategy Returns')
    plt.title('%s RSI Strategy Backtest'%(self.data_name))
    plt.legend(loc=0)
    plt.tight_layout()
    plt.show()

    plt.plot(self.data['Portfolio Value'])
    plt.title('%s Portfolio Value'%(self.data_name))
    plt.show()*****

既然我们已经改变了我们的信号发生器来解释我们的 QDA 模型的预测，让我们初始化我们的 strat2 对象，并将我们的性能与我们的 strat1 策略进行比较。

*****#initializing our strat2 strategy
strat2=optimized_rsi(es,10,'ES',es.iloc[0]['Date'],es.iloc[-1]['Date'])*****

*****#generating signals
strat2.generate_signals()*****

既然我们有了基于 QDA 模型预测的信号，我们可以调用 plot_performance 方法来创建我们的权益曲线，然后比较我们两个策略实施的指标。

*****#plotting performance
strat2.plot_performance(10000)*****

ES RSI Strategy Backtest 2

ES Portfolio Value 2

现在，我们已经创建了动量策略的第二个实例，我们可以计算我们的指标并比较我们的 strat1 策略。

*****#generating metrics
strat2_trades=strat2.data['Total Trades'][0]
strat2_hit_ratio=strat2.data['Hit Ratio'][0]
strat2_win_pct=strat2.data['Win Pct'][0]
strat2_loss_pct=strat2.data['Loss Pct'][0]*****

*****#printing strat2 metrics
print('Strat 2 Hit Ratio:',strat2_hit_ratio)
print('Strat 2 Win Percentage:',strat2_win_pct)
print('Strat 2 Loss Percentage:',strat2_loss_pct)
print('Strat 2 Total Trades:',strat2_trades)*****

*****Strat 2 Hit Ratio: 0.97
Strat 2 Win Percentage: 0.49
Strat 2 Loss Percentage: 0.51
Strat 2 Total Trades: 1323*****

让我们回顾一下我们的战略 1 指标。

*****#getting strat1 metrics
strat1_trades=strat1.data['Total Trades'][0]
strat1_hit_ratio=strat1.data['Hit Ratio'][0]
strat1_win_pct=strat1.data['Win Pct'][0]
strat1_loss_pct=strat1.data['Loss Pct'][0]*****

*****#printing our strat1 metrics
print('Strat 1 Hit Ratio:',strat1_hit_ratio)
print('Strat 1 Win Percentage:',strat1_win_pct)
print('Strat 1 Loss Percentage:',strat1_loss_pct)
print('Strat 1 Total Trades:',strat1_trades)*****

*****Strat 1 Hit Ratio: 0.93
Strat 1 Win Percentage: 0.48
Strat 1 Loss Percentage: 0.52
Strat 1 Total Trades: 22431*****

好吧，有趣的事情发生了。回想一下，我之前说过，我们只赢了 48%的概率并不是问题，问题是转移概率，限制我们的亏损交易。这就是我们建立 QDA 模型的原因，这样我们就可以很有把握地预测什么时候我们可能会进行亏损的交易。

请注意，我们的指标略有变化。

  • 我们的 strat2 命中率确实有所提高，从 strat1 的. 93 提高到了. 97。
  • 我们的战略 2 的盈利百分比从战略 1 的 0.48 增加到了 0.49，这也相当于战略 2 的亏损百分比为 0.51，战略 1 的亏损百分比为 0.52。

注意我们交易数量的显著差异。与我们的 strat2 实例相比，我们在 strat1 实例中进行了更多的交易。

这直接影响到我们的策略成功生产的可能性。我们使用 QDA 模型有效地消除了许多对我们的策略构成问题的交易。另外，看看我们的 strat1 和 strat2 实例的权益曲线。

  • 我们的 strat1 实例结束时的投资组合价值约为 9600。
  • 我们的 strat2 实例在期末的投资组合价值为 10，200 英镑，这低于它的启动阶段，但仍然是对 strat1 实例的重大改进。

考虑到我们的盈利和亏损百分比的微小变化，这是很重要的，并表明还有其他因素在交易策略的盈利能力中发挥着重要作用。如果你仔细观察这一时期的末期，你可以看到我们的 QDA 模型的真实效果。在我们的 strat1 实例中，接近期末时，我们只是直线抛售。但是看一下我们在同一时间段的 strat2 实例，我们实际上显著改进了我们的交易。

当然，相对于这一策略，在我们所学的基础上还可以做更多的事情。但是，这个实验已经证明，这里提出的框架是一个可行的优化日内交易策略。不可否认，这篇文章中提出的策略被设计成有缺陷，以测试使用 QDA 进行优化的想法。换句话说，我并没有试图优化这个策略，只是想要一个显示出一些潜力的策略，就像你现在正在做的一样。所以想象一下，你可以用这个框架和一个你实际上正在尝试投入生产的策略做些什么。

回顾

我们在这篇文章中已经介绍了很多，希望你能从中获得一些有助于你制定战略的见解。

我们首先了解了什么是 QDA，并研究了模型背后的一些数学原理。我们回顾了之前在 LDA 上的 帖子中所学到的内容，并与 QDA 的帖子进行了比较。我们导入了一些 eMini S & P 500 的日内数据，目的是创建一个日内动量策略，并使用 QDA 来改进我们的策略。在构建我们的策略之前，我们做了一些探索性的数据分析，以更多地了解我们的数据集。

我们使用面向对象编程来设计我们的 RSI 策略，这种方式允许我们重用我们的代码并创建多个策略实例。在创建了我们的第一个策略实例之后，我们发现我们的策略还没有准备好投入生产，但是显示出了一些潜在的迹象。然后，我们的目标是建立一个 QDA 模型来预测我们可能在什么时候进行亏损交易，以努力将我们的策略转化为对我们有利的策略。

我们在数据中增加了一个分类栏“回报方向”,并设计了波动率的特征“滞后 3”、“滞后 4”、“滞后 5 ”,以及用于 QDA 模型的相对强弱指数。我们的 QDA 模型显示，预测亏损交易的准确率为 92%。然后，我们将预测应用到数据中，并创建了一个 strat2 实例。虽然我们的盈利和亏损百分比变化不大，但我们的回报增加了 600 美元，而且我们的 strat2 实例，与我们的 strat1 实例不同，实际上是正的。

我们的研究表明，我们的日间机器学习优化框架对于增加我们的策略投入生产的可能性是可行的。我们还可以做更多的事情来改进这一策略，但我们已经传达了总体想法。

挑战:在 Twitter 上给我们发一张你的股票曲线快照

See if you can further build upon the framework presented in this post. Play with the code to see how you might improve this model. Be sure to download the data used in this post via the CSV file below.**********As a bonus, review the post "Using Linear Discriminant Analysis For Quantitative Portfolio Management" and see if you can incorporate that framework into what was covered in this post.**********We'd love to see what you create. Tweet us a snapshot of your strategy's equity curve at @QuantInsti on Twitter. Be sure and use the hashtag #QDA.****

接下来的步骤

If you're interested in learning more about Machine Learning for Trading, Quantinsti offers both a self-paced option, via our Quantra Online Learning Portal, and a comprehensive quantitative trading regimen, the Executive Program in Algorithmic Trading (EPAT).The EPAT program is administered over the course of 6months and covers topics such as Statistics and Econometrics, Quantitative Trading Strategies, Programming in Python and R, as well as Machine Learning. The faculty of the program are current quants with different backgrounds and thus ensures participants that the content will be relevant to the current market and industry environment. If you would like to learn more you may visit us here.If you prefer to learn on your own time and at your own pace, Quantra is a good learning option for you. Through Quantra you'll can lifetime access to courses such as Introduction to Machine Learning for Trading, Trading with Machine Learning: Classification and SVM, and more. To learn more you can visit us here.

免责声明:股票市场的所有投资和交易都有风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。

下载数据文件

  • 数据 CSV 文件

算法交易行业最优秀的人应该具备的 5 个品质

原文：https://blog.quantinsti.com/qualities-best-people-algorithmic-trading/

由查尼卡·塔卡

算法交易行业充满了坚定、上进和热情的人。除了这些性格特征，算法交易行业最优秀的人还有以下 5 种品质:

  1. 优秀的观察者和倾听者
  2. 现实主义
  3. 乐观但有自知之明
  4. [勇敢而执着](#courageous and persistent)
  5. [终身学习者](#lifelong learner)

优秀的观察者和倾听者

在算法交易行业，最成功的是那些对金融市场哪怕是最微小的变化都保持警惕的人。在专注的态度和观察技巧的帮助下，交易者能够加强他们的交易策略。因此，交易者能够更好地最大化他们的回报。金融市场受到经济中发生的微小细节的影响。世界政治，经济趋势，甚至天气都有改变市场趋势的力量。通过了解金融市场过去和现在的情况，交易者为面对未来的波动做好了最好的准备(因为计划内和计划外的情况)。

现实主义者

作为一个算法交易者，你需要成为一个现实主义者，这样你才不会做出错误的决定。例如，在上涨趋势下兴奋地过度交易，害怕错过赚更多钱的机会，或者对过去损失资金的内疚。

下面，你可以看到一个过度自信和过度交易的例子:

来源:雅虎！

在上图中，可以清楚地看到交易者从一只股票跳到另一只股票的速度太快了。由于不稳定，改变交易想法不仅风险太大，还会导致大量交易成本和佣金支出。在算法交易中，交易者的情绪会导致这种高风险的策略产生。因此，成为一个现实主义者是极其重要的。

乐观但有自我意识

交易时，过度自信有风险，乐观和自我意识才是真正的宝石。一个成功的算法交易者保持平衡的情绪，对下一步保持积极的态度。交易时，算法交易者承担计算好的风险，并相信他/她有能力在适当的回溯测试后制定交易策略。

你可以从上图中看到，通过保持平衡乐观的方法，成功的算法交易者总是明智的。有点幽默的是，这张图片显示了专业交易者的宠物知道如何评估风险和回报，并且相信自己的决定！

虽然承担合理的风险非常重要，但当市场走势与预期相反时，通常会出现对风险的识别、评估和缓解的需求。因此，在对市场进行彻底分析的基础上，在预测所有风险之后，设定你的预期是非常重要的。

让我们看一下这张表，它是一个例子，说明承担计算好的风险是多么重要，因为每多损失 5%，你需要弥补损失的收益百分比就会增加。这仅仅意味着损失越大，就越难恢复:

来源:培养基

在这里，投资组合优化是一个重要的过程，涉及分析不同投资比例的投资组合。这个优化过程是通过计算每个投资组合的风险和回报，并选择实现预期风险回报的投资组合来完成的。

推荐阅读:

投资组合&风险管理

勇敢而执着

算法交易者总是愿意承担计算好的风险，并且有足够的勇气去做决定。坚持的态度是算法交易者的另一个最好的朋友，因为它帮助交易者在真实市场中学习。虽然纸上交易开始时要好得多，但交易者学会了在现实市场中交易的实际方法。

这也意味着人们应该避免在金融市场预期表现不佳时做出交易决定。算法交易者不会因为做决定而内疚或害怕，会坚持不懈。

来源:股市行情

终身学习者

不断地研究一个想法，并改进它，最终使它发挥作用，这是在任何领域取得成功的关键。作为算法交易者，你必须尽可能多地学习算法交易。有一些免费资源可以让学习继续下去，还有一些关于算法交易的必备书籍(免费和付费)。

上面提到的是算法交易者的 5 个品质，下面你可以看到算法交易者保持的其他一些关键的性格特征或纪律:

  • 他们不断研究金融市场以获得最佳经验
  • 他们至少知道一种编程语言
  • 他们有定量技能
  • 他们获得数据管理能力

他们不断跟踪金融市场，以获得最佳经验

金融市场是交易发生的各种平台。

  • 交易所——是交易所平稳地运行着购买、出售和交易工具的整个过程
  • 监管当局——监管委员会或机构是监管交易所活动的当局。与证券市场相关的监管机构包括:
  • 美国证券交易委员会(SEC) -监管美国证券交易所/市场
  • 印度证券交易委员会(SEBI) -监管印度证券交易所/市场
  • 分析-分析有三种类型，目标是找出特定证券的正确价值。这些是基本的、技术的和定量的分析。

基本面分析包括现金流、盈利能力、资产负债表规模等因素。

技术分析使用图表软件来可视化价格模式、交易量和运动。

定量分析包括通过数学和统计模型对金融事件的研究。使用统计技术识别交易机会。

  • 交易量——交易量是某一特定时期内某一证券交易的股票或合约总数。而平均交易量是每单位时间的交易量。一只股票的交易量越大，它在市场上的流动性就越高。
  • OHLC——是开盘、盘高、盘低和收盘(OHLC)的缩写。它指的是股票价格的数据集，其中每个数据点有四个价格。例如，有一个特定股票从 2019 年到 2020 年的每日价格数据集，每个数据点(每天)将有四个价格，分别指开盘价、最高价、最低价和收盘价。
  • 趋势-趋势是基于证券价格的市场运动方向。如果价格向上移动，这就是所谓的上升趋势，反之，如果价格向下移动，这就是下降趋势。
  • 订单——订单是投资者向经纪人或经纪公司发出的或直接在交易场所买卖股票、债券或衍生品等证券的指令。可以通过电话或在线手动/通过算法下订单。
  • 价差——在金融学中，价差可以定义为任意两个价格之间的差异。它也被定义为给定证券的当前出价和当前要价之间的差额(买卖价差)。
  • 流动性——流动性是指资产转换为现金而不会在很大程度上影响市场上当前资产价格的能力和难易程度。市场流动性是指市场允许股票、债券或衍生产品等资产在无需支付巨大买卖差价的情况下进行买卖的程度。与其他资产相比，现金是流动性最强的资产。

你应该如何跟随股市？

为了跟踪股票市场的表现，最好的网站是谷歌和经济时报市场。你也可以在经济时报市场的帮助下学习如何跟踪股市。

他们至少精通一门编程语言

虽然有很多编程语言，但算法交易中最优秀的人至少熟悉其中一种。如果你的目标是在算法交易领域获得风险经理或投资/资产经理的职位，那么可以跳过编程，这是不正确的想法。编程语言在算法交易领域非常重要，因为你需要从验证策略假设到回溯测试和执行策略的编程技能。

流行编程语言

你可以学习很多计算机编程语言。然而有一些流行的语言是:Python、C、C++、Java 和 HTML。学习任何一种流行的编程语言都有助于算法交易。

学习编程语言的方法

学习编程语言的最好方法是通过在线课程。网上有各种各样的课程，你可以找到最适合你知识水平的课程。

推荐课程:

众所周知，Python 是程序员/开发者开发交易策略的首选语言，因为它提供了以下优势:

  • Python 有一些用于机器学习和数据科学的 API 和库，与其他语言相比，这些 API 和库使得分析更加流畅。
  • 它帮助交易者快速简单地编码，以图形的形式导入数据和可视化数据。
  • 大多数量化交易者更喜欢 Python，因为它可以帮助他们建立自己的数据连接器、执行机制、回溯测试、风险和订单管理、前向分析和优化测试模块。
  • Python 交易库的首次更新在开发人员社区中经常出现。

他们有定量技能

什么是量化技能？

定量技能包括统计学知识、数学模型和统计研究方法。此外，你的定量技能使你能够有效地找到合适的模型来定义随机性，计算资产价格的变动，并检查市场数据的统计特性等。

如何习得这些命令式量化技能？

为了获得定量技能，有一些简短的在线课程是自定进度和互动的。此外，你可以选择一些知名平台提供的你想学习的具体方面。

在算法交易行业，你需要所有工作角色的量化技能。算法交易中的工作角色包括量化分析师、量化开发员、风险分析师等。通过掌握量化技能，你可以在算法交易领域的每一个工作角色中脱颖而出。Quantra 提供的一些课程有:

用机器学习进行交易:回归

本课程非常适合使用机器学习算法创建您的第一个交易策略。循序渐进地学习:获取数据，预处理数据，训练和测试机器学习回归模型，预测股票价格。提供实际操作的编码帮助。

用机器学习进行交易:分类和 SVM(支持向量机)

学习在金融市场数据上使用 SVM，并创建自己的预测算法。课程涵盖分类算法、机器学习中的性能测量、超参数调整和监督分类器的构建。

神经网络交易

本课程强烈推荐程序员和 quants 在金融市场实现神经网络和深度学习。由欧内斯特陈博士提供，学习使用先进的技术，如 LSTM，RNN 在现场交易。

交易中的决策树

通过这门课程，你将学会使用人工智能技术预测市场和寻找交易机会。此外，你将能够训练算法通过数百个技术指标来决定哪个指标在预测正确的市场趋势方面表现最好。进一步，优化这些 AI 模型，学习如何在实盘交易中使用。

执行方案

有了高管课程，你可以从各种专业人士、行业中坚分子那里学到行业的实际方面。

其中一个项目是算法交易管理项目( EPAT )，这是一个为期 6 个月的综合虚拟课堂项目，涵盖了算法交易的基本模块，例如:

  • 市场微观结构
  • 金融工具
  • 统计数字
  • 数据分析
  • 证券管理
  • Python/Matlab/Excel 编码基础
  • 机器学习的使用
  • 交易、技术、基础设施和运营
  • 实时交易策略构建

该课程通过专注于衍生品、量化交易、电子做市或交易相关技术和风险管理，激励传统交易者走向成功的算法交易生涯。

他们获得数据管理能力

什么是数据管理？

数据管理通常是为了清理直接从源中提取的原始数据，这些数据可能包含多个问题，如重复、非平稳性等。干净和可用的数据是指在交易中随时可用于各种目的的数据，例如回测、分析和预测交易等。数据管理并没有就此结束，它需要确保数据中没有进一步的错误，它是容易访问和可靠的。

数据管理是怎么做的？

数据管理通常由算法交易行业的数据工程师来完成。数据工程师有三种类型:

  • 多面手-他们完成创建数据管道的全部工作，例如从数据源检索数据，对其进行处理并进行最终分析。这一过程占用了数据科学家的全部技能，并且是没有太多专业人员的小公司或团队所需要的。
  • 以管道为中心——中型公司需要它们，这些公司有复杂的数据需求，需要数据团队进行大量需要分布式系统和计算机科学背景的工作。
  • 以数据库为中心——它们通常出现在大型公司中，数据分布在各个数据库中。这些公司中有各种数据分析师，数据工程师需要将信息从数据库的主应用程序中提取到分析数据库中。

结论

尽管算法交易行业最优秀的人不断用先进的知识和专业技能让自己变得更好，这些品质将有助于你的职业发展..这将有助于你在算法交易行业获得最好的工作角色和职位。

希望你喜欢这篇文章，它很好地服务于它的目的！我们想知道你对此的想法，请在下面分享你的评论。

你也可以通过算法交易(EPAT) 的高管课程来开始你升级算法交易知识的探索——这是一门综合课程，涵盖的主题从统计学&计量经济学到金融计算&技术，包括机器学习等等。立即注册！

免责声明:本文提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害负责。所有信息均按原样提供。

使用 QuantInsti 构建 SGX -印度股票和货币衍生品的量化策略技术

原文：https://blog.quantinsti.com/quant-strategy-building-techniques-for-sgx-india-equity-currency-derivatives-with-quantinsti/

https://www.youtube.com/embed/AqLdzheIszE?rel=0

日期:2020 年 10 月 22 日星期四美国东部时间早上 6:30-7:30

IG SGX QuantInsti Ishan Shah Workshop

专业量化策略开发框架的演练，以及构思、设计和回溯测试股票和货币衍生品市场端到端策略的实践方法。

了解量化交易中的最佳风险管理实践。如果你想开始你的量化交易或者给你的策略发展过程添加一个框架，这个研讨会对你来说是完美的。

演讲人:AVP 伊山沙阿，内容&在 QuantInsti 调研

****由主办新加坡交易所

QuantInsti 提供 EPAT 课程，该课程被广泛认为是印度、新加坡和全球最好的交易课程之一。联系课程顾问以了解更多相关信息。

什么会影响量化策略？[小组讨论]

原文：https://blog.quantinsti.com/quant-strategy-panel-discussion-24-september-2020/

https://www.youtube.com/embed/Ne_S7iDuLi0?rel=0

本次网络研讨会已经结束。

2020 年 9 月 24 日星期四

东部时间上午 8:30 | IST 时间下午 6:00 |新加坡时间晚上 8:30

10 岁生日

正如人们所说，知识是人生最大的礼物。在庆祝我们成立 10 周年之际，我们策划了这个系列来感谢我们的社区。我们从心底里感谢你，感谢你多年来在我们的旅途中给予我们的爱和支持！

关于会议

与老派交易者/投资者的自由选择相比，量化交易表面上是基于更客观的标准。它们在系统上比传统的更好吗？我们如何评估何时部署一个策略，何时该放弃它？本次活动中，我们的小组成员将详细讨论其中的一些问题，并为评估量化策略的有效性提供有价值的见解。

面板

Vivek Krishnamoorthy

(内容负责人&QuantInsti 研究)

Vivek 领导 QuantInsti 的内容和研究部门。他曾在新加坡和印度的 ICICI 银行担任企业和机构银行信贷分析师。Vivek 还在加拿大麦克马斯特大学为本科生和研究生教授经济学和金融学课程。

他曾在瑞士瑞信银行 Larsen & Toubro 公司和其他机构为中高层管理人员举办过多次公司金融、金融建模和投资组合理论方面的培训。Vivek 在金融和学术界的丰富专业经验使他成为市场微观结构、量化金融编程和量化交易中使用的统计技术的熟练讲师。

尼古拉斯·拉伯纳

(创始人& CEO FactorResearch)

尼古拉斯·拉伯纳是 FactorResearch 的创始人兼首席执行官。此前，他创建了屡获殊荣的量化对冲基金 Jackdaw Capital，并在伦敦和纽约的 GIC(新加坡政府投资公司)和花旗集团工作。

Nicolas 拥有 HHL 莱比锡管理研究生院的金融硕士学位，是 CAIA 特许持有人，喜欢耐力运动(100 公里超级马拉松)。

Laurent Bernut

(创始人& CEO ASC)

Laurent Bernut 曾在 Fidelity Investments、Rockhampton 和 Ward Ferry 的另类投资领域工作。在富达，他作为专职卖空者的使命是跑输现代史上持续时间最长的熊市:日本股市。

劳伦特在另类空间创造阿尔法的研究是建立在他对普遍测试的系统交易过程的专业知识之上的。

Radovan 的贴身男仆

(量子百科首席执行官)

拉多万·沃伊特科是 Quantpedia 的首席执行官兼研究主管。他是前量化投资组合经理，在五年多的时间里管理了数只量化基金的 3 亿多欧元。这些基金专注于多资产管理期货和趋势跟踪策略、市场时机和波动性交易。

在能源行业工作了 25 年后，学会了定量交易的方法——马克·伦德尔

原文：https://blog.quantinsti.com/quant-trading-25-years-energy-industry-mark/

对于一个有 30 多年工作经验的人来说，Mark Rendle 仍然有学习新事物的热情，并继续学习和成长。我们带来了他的故事。

以下是我们与马克的对话:

Mark Rendle

嗨，马克！你能给我们介绍一下你自己吗？

早上好，我是马克·伦德尔。我是英国/加拿大人，目前住在美国，为一家大型能源公司工作。

工作之外，我喜欢和家人在一起，我们喜欢旅游和山地运动，比如滑雪、滑板和骑自行车。我对市场交易也很感兴趣，并且非常享受这个复杂多变的舞台所带来的智力挑战。

我主要使用算法，因为它们可以对交易策略进行更明确的评估，减轻交易管理的机械负担。

你能告诉我们你的教育旅程标志吗？

那是一个有趣的问题。至少在最初，我采取了一条有些迂回的路线。我 16 岁离开学校，与一家化学品油轮运输公司签约，做了 4 年的海洋工程学徒，之后我又在游轮上做了 4 年工程师。

在这次不可思议的经历之后，我决定(在英国)攻读机械工程学位。此后，我在一家能源公司找到了一份工作，至今仍在这家公司工作。我也有 MBA 学位，现在正在考虑攻读定量金融学硕士学位。

这不是传统的方法，但事后看来，它提供了一个不可思议的基础。

25 年以上的石油工作经验&能源！了解一下你的旅程会很棒。

我有幸在世界各地工作，到处旅行，与令人难以置信的人一起工作，并受到有趣机会的挑战。我最喜欢的地方是北极，那是一个非常特别的地方。我的贡献通常集中在项目的早期阶段，在那里我们评估投资潜力。

你一直在交易自己。你能分享一下你的经历吗？

我在上世纪 90 年代末来到美国，当时市场正处于令人难以置信的牛市，每个人都在谈论市场，交易自己的账户——所以很难不被卷入其中。

我开了一个交易账户，投资了一些我卖房子赚来的钱。我的账户规模增长很快，我觉得我有市场诀窍(和其他人一样)。然后在 2000 年 3 月，市场剧烈波动，我的账户规模迅速逆转。我意识到我没有完全理解市场动态，我没有优势，我不能管理风险，我还有很多要学。

交易在财务上是危险的，需要你做好充分的准备。所以，在 2003 年，我开了一个贸易站账户，开始写代码。这让我能够测试想法，开发策略，并证明它们在市场周期中是稳健可行的。

这就是开始，从那时起，我就把 algo 交易作为一种爱好。

人们对创建自己的算法的想法并不完全开放。你对此有什么看法？

我认为有几个方面。

不要抱有幻想，长期成功交易是非常困难的，这就是为什么 80%的职业基金经理不能战胜市场指数的原因。想想看——80%的人把他们的教育和职业生涯都献给了专业的市场交易，如果他们购买了指数基金，他们会得到更好的服务。

复杂性:学习如何编码，然后部署该代码来自动交易市场是复杂的，需要付出巨大的努力来确保它按照预期执行并提供预期的优势。发展做好这项工作的技能和能力是一项重要的任务。

竞争:如果我们考虑对冲基金和其他投资公司，它们吸引了大量才华横溢的智力人才。正是这些人经常在我们的交易中采取相反的做法——我们真的认为我们能比他们更聪明吗？

计算能力:鉴于上述情况，要取得成功需要难以置信的承诺和奉献。然而，人们不得不担心，算法交易和计算机能力的快速扩张将永久改变市场动态，消除机会的存在，或者至少使机会更难找到。

时间是一种有限的资源，所以这些是我在决定投资时间于市场还是其他我喜欢的东西时考虑的一些背景问题/想法。

也就是说，如果你真的想交易，即使是作为全权交易者，你也需要一套算法——一套明确规定如何管理头寸的规则。如果没有，那么就没有办法论证一个边的存在。

此外，自动化算法将确保你交易的一致性，避免有时困扰自主交易者的纪律崩溃，并把你的时间花在制定成功的策略上，而不是手动执行交易。

学习在几岁停止？

学习应该是一生的事业，没有理由停止——在任何年龄。

学习 Python 是一件有趣的事情，既令人沮丧又收获颇丰。最初，什么都不工作，错误代码毫无意义，它是一个黑洞，消耗你的空闲时间(沮丧)，然后逐渐地它开始凝聚，你用 Python 思考并执行复杂的代码(回报)。

对我来说，这很有见地，强调了坚持不懈和专注于目标的必要性。

你对技术有什么看法，你会如何描述你的交易风格？

利用技术是交易的一个非常有趣的方面。

远程服务器之间支持复杂数学分析和订单生成的实时数据传输非常强大。编写代码来实现这一点是非常值得的。

我的交易方法结合了基本面和技术面的元素。

我会交易一个由多头和空头候选人组成的大型投资组合(以平滑业绩)，然后在投资组合中交易一些策略。

你是如何与 QuantInsti 建立联系的？

真的是偶然。如上所述，我使用 Tradestation，这是一个很好的算法交易平台，但是，它只提供对美国证券的访问，如果你想管理一个更加国际化的投资组合，这是一个限制。因此，我开始寻找一种方法，通过提供国际访问的交互式经纪人来部署我的贸易站算法。

最初，我只是想找一门关于 Python 的课程，但无意中发现了 QuantInsti 在 EPAT 开设的课程，并发现该课程非常吸引人。我的想法是“如果我要与对冲基金竞争，那么我需要很好地了解这些材料”。所以，我很快就报名了。

QuantInsti 建立了一个后 EPAT 学习和联系校友的社区，这很好。我当然对利用这种资源感兴趣。

就交易而言，你的下一步是什么？

我现在正在完成代码，以通过交互式经纪人平台实施我的策略，并执行一些非常复杂的投资组合分析，所以这是第一步。

然后，我将重温在 EPAT 期间教授的许多概念，并将可行的特征整合到我当前的策略中。此后，我们将看到这一旅程如何继续。

你愿意为那些想进入算法交易的人分享一些东西吗？

正如我前面提到的，如果你的目标只是赚钱，而你并没有完全被市场吸引，那么你最好买一只指数基金(比如蜘蛛)。为自己节省时间、金钱和挫折，做一些对你更有意义的事情。

然而，如果你对市场充满热情，那么算法交易有可能加速你的学习，更清楚地展示你的优势，完善你的执行。对我个人来说，这是一项非常有益的终身事业。

你在 EPAT 的学习经历如何？

EPAT 项目是一次难以置信的学习经历。课程高度相关，讲座和相关材料非常出色，支持一流，在线学习环境非常有效。

这个课程虽然不便宜，但却体现了令人难以置信的物有所值，任何认真对待自身发展的交易者都会从 EPAT 的课程中受益。我要感谢 QuantInsti，并亲自感谢所有相关人员的出色工作。谢谢大家！

非常感谢你抽出时间，马克！和你谈话是我的荣幸。我们祝你在交易生涯中取得更大的成功，学到更多知识，拥有一个美好的旅程。我们非常感谢你对 EPAT 和 Quantinsti 的赞誉。

EPAT 是一门综合课程，涵盖的主题从统计学和计量经济学到金融计算和技术，包括机器学习等等。开始你的探索，与 EPAT 一起提升你的算法交易知识。点击查看。

免责声明:为了帮助正在考虑从事算法和量化交易的个人，本案例研究是根据 QuantInsti 的 EPAT 项目的学生或校友的个人经历整理的。案例研究仅用于说明目的，并不意味着用于投资目的。EPAT方案完成后取得的成果对所有个人而言可能不一致。T15】

定量交易策略——基本面分析和定量分析

原文：https://blog.quantinsti.com/quantamental-trading-strategy/

作者:安基特·阿胡佳

在这篇博客中，我们将制定一个交易策略，其中我们将对这些公司的基本面数据进行定量分析，并创建一个基本面强劲的公司的投资组合，并分析该投资组合的表现。

本博客涵盖的主题:

  1. 什么是基本面分析？
  2. 什么是定量分析？
  3. 为什么要利用基本面数据制定交易策略？
  4. 如何制定量化策略？
  5. 回测结果
  6. 对比纳斯达克的策略绩效

什么是基本面分析？

在会计和金融中，基本面分析被定义为对公司财务报表的分析，即资产负债表、损益表和现金流量表。

这种分析背后的动机是指出债务和其他可能导致公司垮台的危险信号。这种分析有助于判断公司未来几年/几个季度的整体表现和健康状况。

该分析使用各种财务比率，例如:

价格收益比(市盈率)

市盈率的计算方法是将股票价格除以每股收益。该比率用于了解公司相对于同行或市场的估值。

市净率

该比率的计算方法是将股票价格除以权益的账面价值，或者换句话说，股票价格除以其账面价值。这个比例特别有助于判断公司的价值，是低估还是高估。

企业价值与销售额比率(EV/销售额比率)

该比率的计算方法是将企业价值除以公司的销售额或收入。这个特定的比率有助于根据销售额来评估一家公司的价值，同时考虑债务和权益。

债务权益比率

债务权益比率或杠杆比率是一个特别有助于分析公司债务水平的比率。无论公司是否过度举债。换句话说，公司有多少资金是由债权人和银行提供的。

净债务对 EBITDA 比率

这个比率也就是杠杆率，用来计算公司的杠杆率。它描述了公司偿还债务的能力，或者我们可以说，一个公司必须在多长时间内管理其当前的运营以偿还其当前的债务。通常要求较低的价值，因为它显示了公司产生现金和支付债务的能力。

债务与资产比率

资产负债率是通过将债务除以公司的总资产来计算的，这个比率用来了解公司有多少资产是由债权人提供的。较低的比率表明公司能够为未来可能出现的新机会自筹资金。

基本面分析也被用来计算公司的内在价值。这有助于投资者和交易者识别低估或高估的公司。所以，他们可以据此做出决定。

什么是定量分析？

当各种统计技术和其他数学模型被用于执行某种分析或过滤时，这种分析被称为定量分析。它可以用来识别满足特定条件的股票。这些条件可以是一些数学等式或过滤器。

最终目标是将可用的信息量化成数值，以便于决策。在这种分析中，人们使用各种财务比率，并将它们输入到一个模型中，该模型具有预先定义的步骤，利用统计技术或数学公式，并给出期望的输出。

为什么要用基本面数据做交易策略？

纳斯达克跟踪了各行业的 3300 多只股票。但这里的问题是:

投资哪里，如何挑选表现最好的股票和好公司？

根据 Fama 和法国教授撰写的一篇关于要素投资的论文，我们知道，从长期来看，价值公司的表现比其他公司更稳定。但与此同时，一个问题也出现在公司的基本实力上。

公司是基本面强大，相对被低估还是因为基本面薄弱而被低估？

所以问题是，

难道不能考虑以上两种说法，制定一个策略吗？

这种策略能够让我们看到一系列公司，与前几个季度相比表现更好，但与同行相比也相对被低估。

正如我们所知，在新冠肺炎疫情事件后，一些公司在没有任何进一步通知的情况下，一夜之间就停止了运作。因此，我们需要选择有大量基本面支持的公司，如现金储备和强劲的利润率，以应对市场的这种起伏。

如何制定量化策略？

该配方分为两部分:

  • 对照同行评估一家公司。
  • 用自己评价公司过去的业绩。

对照同行对公司的评估

  1. 纳斯达克 14 大科技股是由市值选出的。

  2. 下面列出的比率用于评估公司与其他公司的对比。

  • 市盈率(P/E 比率)。
  • 市净率。
  • 企业价值与销售额比率(EV/销售额比率)。
  • 债务权益比率(D/E 比率)。
  • 净债务与 EBITDA 比率。
  • 债务与资产比率。

为了得出公司的价值因素，我们取这些比率的倒数。

在取这些比率的倒数后，我们将取这些比率的 Z 值。Z 分数背后的基本原理是使比率正常化并消除任何偏差，然后将使用评分算法来计算公司的最终分数。

分数越高，相对于它的同辈，它就越被低估。

评分算法:编写了惩罚算法，参考了“ S & P 值 bse 因子指标论文”，其中如果 Z 值大于 0。然后在分数上加 1，当分数为 0 时，用 1 代替。在小于 1 的地方，罚函数是 1/(1-z)。

我们使用了基本面分析包的函数“key_metrics ”,因为它也返回前一年的比率。列出的代码片段显示了比率的检索。

注意:你必须通过访问金融建模准备网站获得你自己的免费 api 密匙。

量化新闻分析:盈利能力与陷阱

原文：https://blog.quantinsti.com/quantified-news-analytics-profitability-pitfalls/

cover pic quantified news trading

随着新闻来源和数量的增加，收集、提取、汇总和分类的技术也在发展。重要的新闻会带来巨大的正面或负面回报。然而，由于许多新闻来源，我们需要问一个基本问题:新闻分析是在每种情况下都有利可图，还是有一些陷阱需要避免？

新闻分析中的信息流

news analytics in finance

来源:新闻分析在金融中的应用:回顾，OptiRisk Systems

定量新闻分析的盈利途径

小型公司

  • 与中型或大型股相比，小型股对新闻情绪的反应更为强烈。
  • 大盘股吸引了更多分析师的关注，媒体也给予了大量报道。
  • 小盘股仍然难以捉摸，因此有关它们的消息会对市场情绪产生更大影响

贝塔系数低的股票

  • 低 beta 的股票在大盘指数变动时波动不大。
  • 由于波动性较低，受市场影响较小，它们对情绪波动非常敏感

低 VIX

  • VIX 作为一个动态指标，反映了市场的波动或“恐惧”。
  • 当市场相对被动，VIX 较低时，突发事件会刺激情绪指标。
  • 在波动性更大的市场中，人们对正面消息的反应不那么强烈，而对负面消息的反应更强烈。

软新闻对硬新闻

  • 与基于事实的硬新闻相比，基于观点的软新闻的短期反应要弱得多。
  • 负面新闻有能力使股票价格暴跌。

量化新闻分析的陷阱

双重否定

  • 如果标题和正文有双重否定，新闻分析有时会失败。
  • 例如，2012 年奥萨马·本·拉登被击毙时，新闻机器人将此视为负面消息，并抛售股票
  • “本拉登”和“被击毙”双重负面消息的出现引发了交易信号

陈旧的新闻

  • 关于一个事件或一家公司的陈旧新闻会触发情绪指标。
  • 例如，2002 年一则关于联合航空公司破产的旧新闻，被谷歌 2008 搜索到
  • 这导致投资者的财富大规模消失，因为联合航空的股票立即暴跌。

恶作剧/假新闻

  • 一般来说，基于新闻的交易者依赖可信的新闻机构。
  • 然而，在帐户被黑的情况下，新闻可能被证明是假的。
  • 例如，美联社(AFP)的推特账户在 2013 年遭到黑客攻击，并在推特上发布了白宫发生爆炸的虚假消息。立刻，
  • 道琼斯指数下跌 0.8%，随后反弹。

信息图表

quantified news analytics

后续步骤

如果你有兴趣了解更多关于量化新闻分析如何工作以及如何基于此设计交易策略的信息，请看这个网络研讨会。此外，看看我们的旗舰课程“算法交易高管课程”，接受培训，开始自己的算法交易。

QuantCon 2017:亚洲的算法交易机会

原文：https://blog.quantinsti.com/quantinsti-at-quantcon-2017/

QuantCon 2017 由 Quantopian 主办，于 4 月 28 日日至 30 日日在纽约市举行。会议的特色是专家研讨会和讲座，讨论如何克服算法交易、量化金融和机器学习的障碍。

QuantCon 的 Rajib Ranjan Borah

Rajib Ranjan Borah addressing the audience at QuantConT2】

我们的主任 Rajib 是 QuantCon 大会上众多著名演讲者之一。他谈到了亚洲的算法交易机会-法规，技术，竞争格局，机会。

美国的高频和算法交易市场竞争非常激烈。明白了这一点后，Rajib 解释道，对于那些已经积累了专业知识的公司来说，关注亚洲的新兴市场已经变得越来越谨慎。在亚洲使用类似的努力和专业知识可能会产生更高的利润，并为一些新市场提供先发优势。

然而，这条道路充满了独特的障碍，对挑战和可能性的内在洞察力是至关重要的。QuantCon 上的这次演讲有望消除一些困惑，并为算法交易业务在亚洲的扩展提供更多的线索。

总之，对于 QuantInsti 来说，这确实是一个与 QuantCon 合作并为算法交易、量化金融和机器学习领域做出贡献的绝佳机会。

下面是我们图库中 QuantCon 演讲者的照片:

QuantInsti 是 2015 年 Finbridge Expo 的知识合作伙伴

原文：https://blog.quantinsti.com/quantinsti-finbridge-expo-2015/

Finbridge Expo 2015T2】

金融服务和技术展 FINBRIDGE 于 2015 年 3 月 14-15 日在孟买的孟买展览中心举行。

日期-2015 年 3 月 14 日-15 日

地点- 孟买展览中心- NESCO，Goregaon(东部)，孟买-400063

事件概述

在这个为期两天的大型活动中，展示了电子交易、风险管理、后台办公、银行和其他金融市场解决方案的全部技术，包括股票经纪、商品交易、高频交易软件(算法交易)。

QuantInsti 被邀请成为其知识合作伙伴，并为与会者举办关于算法和高频交易的各种主题的研讨会，以便他们可以获得关于自动化交易如何帮助他们的业务的信息。有了这个工作坊，更多的实物交易者现在有了使用算法进行交易的知识。

算法交易工作坊 节目

  1. 算法交易中的技术优势-提高交易利润的工具和创新-same er KumarTime:15.25-16.05，2015 年 3 月 14 日
  2. 量化交易策略的盈利能力分析和资金管理- Shaurya Chandra 时间:2015 年 3 月 14 日 16:15–17.00
  3. 下一代交易策略:通过量化新闻进行自动化情绪分析- Rajib Ranjan Borah 时间:2015 年 3 月 15 日 15:00 - 15:45
  4. 利用大数据(使用开源工具)设计量化交易策略-实践演示-Anil YadavTime:2015 年 3 月 15 日 15:20 - 16:05

关于演讲者

  • Sameer Kumar: 伊拉克资本&总监(基础设施开发)——QuantInsti
  • Shaurya Chandra: 联合创始人兼董事- iRageCapital &联合创始人 QuantInsti
  • Rajib Ranjan Borah: 联合创始人兼董事- iRageCapital & QuantInsti
  • Anil Yadav: 负责人(交易策略绩效改进)&总监 QuantInsti

自动交易会议

要点

  1. 如何实现更低的延迟和连接
  2. 如何领先市场监管一步
  3. 如何跟上新的趋势和技术
  4. 如何提高执行力、风险控制程序和合规性
  5. 如何使用自动化策略来利用期货、期权、外汇和股票市场
  6. 围绕算法、自动化交易、高频交易的使用，以及买方关注的问题有哪些。
  7. 印度自动化交易的未来

时间:【2015 年 3 月 14 日 14:30 - 15:15

演讲者

  • Gaurav Raizada: 联合创始人兼董事- iRageCapital &联合创始人- QuantInsti

实时算法交易平台演示

在我们的展位上，除了我们的“算法交易执行程序”，我们还展示了一个实时算法交易台的演示。

这个演示有助于理解，

  • 算法交易系统架构
  • 各种算法交易方法和策略
  • 著名的算法交易软件和平台

想了解更多关于“算法交易工作坊”的信息，请随时联系我们或致电 +91-22-6169-1400 。

QuantInsti &高盛资产管理研讨会

原文：https://blog.quantinsti.com/quantinsti-goldman-sachs-asset-management-seminar/

QuantInsti - Goldman Sachs Asset Management Seminar

日期:2015 年 5 月 15 日

地点:BKC 孟买索菲特酒店

发言者 : Rajib Ranjan Borah、Gaurav Raizada、Radhakrishna Pendyala 和 Sameer Desai

活动日程

  • 量化自动交易的消息 -晚上 7:15 到 7:45
  • ETF 中的机会 -晚上 7:45 至 8:15
  • 高频市场微观结构 -晚上 8:15 到 8:45
  • 晚餐&网络——晚上 8:45 到 10:30

扬声器

quantin STI 量化学习有限公司的雄辩演讲者:

Rajib Ranjan Borah 是 irage capital Advisory Pvt Ltd .&quantin STI Quantitative Learning Pvt Ltd .的联合创始人&董事。他在 上就自动化交易的量化新闻进行了发言和讨论。

Gaurav Raizada 是 iRageCapital Advisory Private Ltd .的董事，负责该公司在印度的系统、性能和战略咨询业务，他还就高频市场微观结构发表了演讲。

来自高盛资产管理的雄辩演讲者:

Radhakrishna Pendyala 是高盛资产管理投资团队印度 ETF 业务的一员，在设计新投资产品和开展研究相关活动方面拥有丰富的经验。他在 Fidelity Investments、Modelytics 和 NumberPlus India Private Limited 拥有超过 12 年的行业经验。Radhakrishna 之前完成了 IIT 马德拉斯大学的毕业，以及印多尔 IIM 大学的研究生毕业。他还获得了纽约城市大学的金融工程硕士学位。

Sameer Desai 在资本市场拥有约 24 年的经验，涉足的领域包括机构股权销售、私人财富管理、独立财务顾问(IFA)集团、ETF 和指数化。他是高盛资产管理(印度)私人有限公司的执行董事，负责垂直股票经纪业务，其产品主要是 ETF。在收购 Benchmark Asset management India PVT . ltd .后，他加入了高盛印度资产管理公司。在加入 Benchmark Asset Management 之前，他曾担任 JM 金融服务私人有限公司和 Prabhudas Liladhar 私人有限公司的副总裁，这两家公司都是印度领先的金融服务集团。他在基准资产管理公司(Benchmark Asset Management)就指数化和 ETF 在印度各地做了无数次演讲。他来自印度孟买，专攻化学工程的聚合物技术分支，也从事管理研究。

事件焦点

该活动的重点是利用新闻和市场微观结构在交易者、投资者和财富管理人员中传播关于交易技术和策略新发展的意识。它还关注了交易所交易基金中的机会。

QuantInsti 在艾哈迈达巴德 IIM 的算法交易会议

原文：https://blog.quantinsti.com/quantinsti-iim-ahmedabad-2018/

QI at IIM Ahmedabad

概述

QuantInsti 在艾哈迈达巴德的印度管理学院主持了一个关于算法交易的会议。这是一场由 Nitesh Khandelwal(quanti STI 联合创始人兼首席执行官)和 Prodipta Ghosh(quanti STI 副总裁)代表 quanti STI 为 IIM 艾哈迈达巴德的学生举办的有趣会议。

很高兴看到这么多聪明的初露头角的经理对算法交易和量化交易感兴趣！

关于演讲者

Nitesh Khan delwal(QuantInsti 联合创始人兼首席执行官)

Nitesh Khandelwal 毕业于 IIT 坎普尔大学电气工程专业，并获得了 IIM 勒克瑙大学的管理学研究生学位，他的职业生涯始于财政部的银行部门。在一家自营交易公司短暂担任领导后，他在孟买共同创立了 iRage。如今，iRage 是印度算法交易领域的领先企业。后来，当 Nitesh 搬到新加坡时，他成立了一家贸易公司，在全球交易所进行交易。

2016 年，他将重心转移到 QuantInsti 担任其 CEO。QuantInsti 继续致力于将面向科学&技术的贸易知识和途径带给全球大众，并且已经帮助来自 130 多个国家的用户实现了同样的目标。

prodipta-ghoshT2】

Prodipta Ghosh(QuantInsti 副总裁)

Prodipta 是一位经验丰富的 quant，目前作为副总裁领导 QuantInsti 的 Fin-tech 产品和平台开发。

他在银行业工作了十多年，在孟买和伦敦的德意志银行的交易和结构部门担任过各种职务，并在渣打银行担任企业银行家。在此之前，Prodipta 作为科学家在印度国防 R&D 组织(DRDO)工作。

QuantInsti 为 NSE 的 NCFM 认证设计了算法交易模块

原文：https://blog.quantinsti.com/quantinsti-nse-ncfm-module/

QuantInsti Authors Algorithmic Trading Module for NSE’s NCFM Certification

国家证券交易所(NSE)是覆盖全国多个城市的最大证券交易所之一。领先的机构采取主动，建立了 NSE，以提供一个现代化的全自动屏幕交易系统，覆盖全国。众所周知，NSE 带来了无与伦比的透明度、速度以及效率、市场完整性和安全性。就市场微观结构、市场惯例和交易量而言，NSE 在印度证券改革中发挥了催化作用。

金融部门有一个非常重要的方面，那就是开发一个人力资源库，在该行业的每个领域都拥有合适的技能和专业知识。为了拥有这样的熟练和专业的人员，需要向在该行业中工作的人员分配高质量的中介:

  1. 遵循通常通过规章实现的行为准则
  2. 拥有通过测试和认证系统获得的必要技能和知识

认证的必要性

随着算法交易的出现，仅在 NSE 中，算法交易就以指数级增长，占平台交易的 46%。自 2008 年 4 月 SEBI 开始允许直接市场准入以来，交易技术发展的趋势一直保持不变。

着眼于保护投资者&考虑国际经验；为了最大限度地降低因对市场缺乏了解而产生的风险，NSE 引入了认证和测试。近年来，随着市场经历了彻底的转变，出现了各种需要不同专业化和定位水平和性质的新功能。

关于 NCFM

NSE 在金融市场的认证；俗称 NCFM 是一个在线测试和认证计划。在金融市场运作所需的技能和实践知识受到考验。

认证考试面向各行各业想要从事算法交易或拥有算法交易平台的人。跨城市的 VSAT/租用线路网络技术允许灵活的日期、时间安排，并为候选人提供方便。

NCFM 有各种模块，涵盖广泛的垂直交易领域，即。共同基金、股票衍生品、商业银行、证券市场、银行基本面和资本市场基本面

然而，这还不够！考虑到市场和技术的指数变化，NSE 推出了另一个独特的模块，即算法交易模块

由于 QuantInsti 是亚洲算法交易教育的先驱机构，NSE 邀请 QuantInsti 开发其 NCFM 认证的算法交易模块。QuantInsti 开发的 NCFM 工作手册已经发布；其轮廓可以在这里获得。

有鉴于此，QuantInsti 第二次与 NSE 一起成功开展了关于算法交易的管理发展项目 (MDP)。在 2014 年举行的首届 MDP 中，我们的教员展示了各种自动化交易策略、工具、绩效评估技术、投资组合管理技术、规则和法规。

QuantInsti 参加价格展望会议和展览

原文：https://blog.quantinsti.com/quantinsti-price-outlook-conference-exhibition-2015/

POC2015

关于事件

著名的棕榈油和月桂油价格展望会议和展览(POC)每年在马来西亚吉隆坡举行，吸引了来自 50 多个国家的油脂行业的国际参与者的参与。

这次旗舰会议是由马来西亚证券交易所衍生品组织的，该交易所经营着世界基准的原油棕榈油期货合约或 FCPO。这项活动被全球食用油玩家指定为一项必须参加的年度活动。它为来自世界不同地区和价值链流程的代表提供了交流思想的完美网络平台。

QuantInsti at POC2015

QuantInsti 受邀为与会者提供期货和期权方面的教育，以便他们能够获得衍生品如何帮助其业务的信息。有了这个工作坊，更多的实物交易者现在有了使用衍生品进行交易和风险管理的知识。

日期-2015 年 3 月 2 日至 4 日

地点 -马来西亚吉隆坡香格里拉酒店

节目

poco2015 马来西亚证券交易所衍生品研讨会

2015 年 3 月 2 日:上午 8 时 30 分至下午 1 时

| 时间 | 项目 |
| 上午 8:30 | 注册开始 |
| 上午 9 点 | 开场白 |
| 上午 9 点 15 分 | 研讨会论文 1:贸易期货&领先于市场 Nitesh Khandelwal 衍生产品培训部门主管&QuantInsti 跨市场研究 |
| 上午 10 点 15 分 | 茶歇 |
| 上午 10 点 35 分 | 研讨会论文 2:贸易选择&领先于市场Rajib ran Jan Borah QuantInsti 联合创始人&董事 |
| 上午 11 时 35 分 | 问&答 |
| 中午 12 点 | 午餐 |
| 下午 1 点 | BMD 研讨会结束 |

关于演讲者

Nitesh Khandelwal 先生，QuantInsti&市场间研究衍生品培训部主任。

Rajib Ranjan Borah ，QuantInsti 高级教师，期权概念&交易策略和做市。

QuantInsti 受邀参加 2015 年芝加哥贸易展

原文：https://blog.quantinsti.com/quantinsti-the-trading-show-chicago-2015/

The Trading Show Chicago 2015

2015 年 5 月 26 日邀请帖:

日期:2015 年 6 月 3 日-4 日

地点:美国伊利诺伊州芝加哥海军码头，邮编 60611

事件概述

QuantInsti 联合创始人兼董事 Rajib Ranjan Borah 受邀参加 2015 年 6 月 3 日和 4 日在芝加哥举办的“交易展”。芝加哥交易展是芝加哥(以及美国)交易行业的主要活动之一——结合了量化金融、自动化交易、交易所技术、大数据和衍生品。来自对冲基金、交易公司、道具店、银行、经纪人、交易场所、监管机构和金融服务提供商的 1000 多名代表参加了此次活动。

近 100 名行业专家受邀担任演讲嘉宾，包括来自交易技术公司、量化交易公司、交易所、美国财政部等政府机构的专家。

这次活动历时两天，包括 26 场个人会议(17 场研讨会和 9 场专题介绍)和 38 场圆桌小组讨论。此外，有 60 家参展商参加了此次活动。

QuantInsti 的 Rajib 受邀与 Bullet Hill Capital LLC 的创始人兼管理成员 Brett Schlapfer 共同主持圆桌讨论“情绪分析——使用计算语言学识别交易机会”(6 月 4 日上午 10:10)。

参加此次讨论的其他小组成员包括 Ernie Chan(QTS 资本管理公司负责人)、Roger Hunter(QTS 资本管理公司首席软件架构师)、Christian Rojas(加拿大皇家银行资本市场公司定量分析师)、Jeff svo Boda(Makk Trading 公司管理成员)。

当天 13:40，在一个圆桌小组会场——Rajib 也主持了一场“亚洲市场的算法交易”的公开讨论。

当天晚些时候，在 14:40，QI 的 Rajib 是本次活动的最后一位演讲者，他的主题是“亚洲市场的算法交易——监管、技术复杂性和竞争格局”。

芝加哥 2015 交易展图片

马来西亚证券交易所衍生品交易 BMD 会议

原文：https://blog.quantinsti.com/quantinsti-trading-bmd-bursa-malaysia-derivatives/

Trading BMD

日期:9 月 26 日，周六

会议时间:IST 时间上午 10:30 到 IST 时间下午 1:30

午餐: 下午 1:30 到 2:30 IST

地点:QuantInsti Quantitative Learning Pvt Ltd，A-309，Boomerang，Chandivali Farm Road，Powai，Mumbai–400 072

为了让行业和证券交易所参与进来，分享他们在“算法交易管理课程”方面的知识和专业技能，并提供课程之外的持续学习，我们举办了一场由马来西亚主要交易所举办的专场会议，“马来西亚证券交易所衍生品(BMD)T1”。

BMD 是马来西亚首屈一指的股票和期货交易所，提供多样化的期货和期权，涵盖利率、商品、股票指数和单一股票期货产品。

我们为马来西亚证券交易所的“交易 BMD** 开了一个非常成功的会议。**本次会议由 QuantInsti 提供，由 CME Bursa Malaysia 的资深专家在 QI 报告厅主持。

会议涵盖以下主题:

  • BMD 的产品
  • 变化中的马来西亚衍生品市场
  • 治理结构
  • 期货交易的作用
  • BMD 中的传播和套利机会
  • BMD 棕榈油期货

未能参加活动的参与者在线加入了我们。

如需了解更多此类活动的信息，您可以通过contact@quantinsti.com联系我们

如何成为一名量化分析师？

原文：https://blog.quantinsti.com/quantitative-analyst/

由查尼卡·塔卡

作为一名需要综合运用数学、金融和计算机技能的定量分析师或定量分析师，你肯定能拿到高薪，而且会很受欢迎。此外，对于一个定量分析师的角色，你需要有一些关于这个角色的技能、教育和知识。我们已经在前面详细讨论了这些方面以及一些更像薪水、职责和角色的方面。

本文涵盖:

什么是量化分析师？

作为定量分析师，你需要扮演专业人士的角色，运用复杂的数学和金融知识对证券进行定价和交易。定量分析师需要增加收益，降低风险。记住，量化分析师的角色不同于风险分析师的角色。

也被称为定量分析师，量化分析师越来越受欢迎，他们直接与交易者合作。通常，投资银行和对冲基金非常需要定量分析师。

现在，让我们找出你应该成为定量分析师的理由。

为什么要成为量化分析师？

作为一名定量分析师，你的工作既有挑战性又有趣。看看这些为什么你应该成为定量分析师的理由:

  • 有益的工作
  • 是一项刺激的工作
  • 行业内的高需求

有益的工作

作为一名定量分析师，你的专业和财务成长依赖于你通过最大化收益来做好你的角色的能力。薪资如此优惠的主要原因是这份工作的挑战性。这就是为什么它是许多专业人士梦寐以求的工作。

是一项刺激的工作

作为一名定量分析师，你需要通过研究、开发和实现数学模型以及金融和计算机知识来解决复杂的问题。这种参与使工作相当刺激，你的工作需要最少的监督，同时承受着相当大的工作压力。面对这样一份竞争激烈、要求苛刻的工作，这成了一件极其刺激的事情。

行业内的高需求

由于定量分析师的工作性质相当复杂，因此该行业的需求量很大。随着对冲基金对定量分析师的需求不断上升，对工作概况的要求也出现了积极的转变。此外，风险管理行业是另一个需要定量分析师担任风险管理官的行业。

让我们找出定量分析师或量化分析师的工作职责/期望。

Quant 的工作职责/期望

据《经济时报》报道，到 2022 年，印度的数据消费量预计将增长 72.6%，达到 1096587.93 亿 MB。随着如此大规模的数据生成，公司将需要能够发现模式和趋势、建立模型、预测、预报和解释这些数据结果的专业人员。

因此，有了所有的数据和技术来分析和建立算法模型，作为一名定量分析师或定量分析师，你一定会为自己开辟出一条不同寻常的道路。

我们已经讨论过定量分析师的工作是至关重要的。由于涉及到计算机、数学和金融等学科的知识，一般来说，定量分析师需要履行以下职责:

  • 帮助进行交易的交易架构
  • 评估贸易理念
  • 降低交易成本
  • 帮助减少市场影响，如经济衰退
  • 降低投资组合风险
  • 回溯测试和执行新策略
  • 利用数据分析市场和设计算法模型来解决复杂的金融问题

我们在这里提到的一家知名公司 iRage 的不同类型的“分析师”工作有不同的工作职责:

初级分析师

作为初级定量分析师，你将从微观和宏观两个角度参与分析市场。具体来说:

  • 分析来自交易所的数据，建立交易策略
  • 在微秒时间框架内分析市场参与者的活动，以确定可以成功交易的微观行为模式
  • 同时，分析更长时间范围内的信息(以及来自其他金融工具、基本面数据)以建立宏观交易策略
  • 目标是自动化上面建立的所有交易策略
  • 构建工程解决方案来管理复杂性
  • 评估各种时间范围内各种金融资产的各种交易信号的盈利能力
  • 与公司的高级交易员合作执行分析功能(盈利能力分析、市场趋势分析等)。)并相应地准备报告

所需技能:

  • 良好的 Python 编程(最好是 C++)
  • 对金融市场和基本面的基本认识
  • 很强的逻辑和数量能力
  • 强大的教育背景
  • 热衷于使用大数据集

定量分析师

作为定量分析师，以下是工作职责:

  • 将与全球顶级对冲基金和资产管理公司的首席信息官、项目经理、分析师和交易员密切合作
  • 能够理解客户的投资流程，发现效率低下的地方，开发独特、直观、有洞察力的工具，帮助客户做出更好的投资决策
  • 分析和解释来自各种来源的大量财务和统计数据，更好地理解所涉及的挑战并设计优化的解决方案
  • 识别瓶颈，使代码更精简、更快速，创造性地使用技术技能来解决现实世界的问题
  • 能够在快节奏的环境中进行多任务处理并取得成功，创新，解决方案驱动的工作方法

所需技能:

  • 精通 R 和/或 Python
  • 对金融市场的知识和热情
  • 个人交易帐户，你可以说话是一个加号

定量研究分析师

对于这种情况，你需要牢牢掌握数学和计量经济学，同时具备理解和交易市场的能力，同时在设计稳健的交易系统和完善程序方面拥有良好的实践经验，以有效管理各种类型的金融市场数据，促进量化投资研究。

以下是工作职责:

  • 实施统计方法，利用 PyTorch 和张量流解决具体的业务问题
  • 直接参与自动预测系统的设计和开发
  • 与研究人员、软件开发人员和企业领导合作，定义产品需求，提供分析支持，并交流反馈
  • 以一种可立即用于回答有关预测系统的输入和输出问题的格式呈现关键数据，并提高其性能
  • 使用深度学习等前沿概念来识别金融市场数据中的模式/趋势

所需技能:

  • 应该能够熟练地将高级数学/统计学概念应用于大型数据集
  • 优秀的分析和解决问题的技能
  • 必须具备求知欲，并主动积极
  • 具有 Python、Pytorch 和 Tensor Flow 的工作经验和亲和力
  • 对机器学习等现代概念和定量金融理论着迷并感兴趣
  • 研究和分析各种大型数据集，以开发和实施信号
  • 与他人广泛合作，分析业绩，优化交易策略，并继续推进团队的研究成果
  • 使用深度学习等前沿概念来识别金融市场数据中的模式/趋势

高级定量分析师

作为一名高级定量分析师，您的职责包括:

  • 设计、回测和实施交易策略，并作为研究团队的一部分工作
  • 对历史市场数据进行研究
  • 开发新的或改进现有的指标和交易模型
  • 各种交易策略的编码
  • 监控实时交易策略并保持最佳表现
  • 分析大型金融数据集以识别交易机会
  • 提供实时分析支持
  • 研究、设计、金融工程和测试跨资产类别的证券、指数及其衍生品交易的量化模型。这个人需要了解定量金融的研究
  • 创建和审查战略代码，最好是 R 和 MS-Excel，但其他语言也可接受，取决于具体的候选人概况。
  • 作为策略团队的一员，决定在什么情况下使用什么信号和交易策略

所需技能:

  • 熟练使用 R 和 Excel 进行统计/数据分析
  • 机器学习和时间序列模型的实用知识
  • 强烈的职业道德
  • 对股票市场和金融数据的兴趣
  • 良好的解决问题、批判性思维和分析能力
  • 了解 R Shiny、Markdown/ Latex 和 Python
  • 熟悉印度股票市场

还有，你可以用 quant 面试题准备的一整个课程来练习 Quant 面试题。

接下来，我们将看看成为定量分析师所需的教育要求/技能。

成为定量分析师的教育要求

由于定量分析师需要完成我们刚刚讨论过的各种功能，所以了解成为定量分析师的教育要求是很重要的。

下面，我们提到了一系列在线课程、学位以及证书课程，你可以从中选择，成为一名定量分析师:

金融工程硕士

由于金融工程硕士为你提供了从评估统计数据到计量经济学建模的深入知识，这是一门在现实世界中帮助你的工程课程。由各种大学提供，你可以在全球任何一个角落注册这个学位。

当你获得定量分析的专业知识时，你就可以自信地完成这篇文章。在学习本课程的过程中，您将在以下重要主题的背景下获得全面的金融知识:

  • 统计数字
  • 数学
  • 计算机科学

总之，在这样一个快节奏的世界里，这门课程将使你具备在需要特殊工作的专业环境中取得成功的正确知识。

数据科学硕士

在这个学位课程中，你将学习所有关于数据科学的知识，它基本上帮助你将统计学、数据分析、机器学习联系起来。所有著名的大学都提供这个学位。一旦你掌握了所有这些领域和相关的概念，你就可以将所学学科的复杂性用于实际应用。这个学位课程涵盖了数学、统计学、计算机科学和信息科学等各个领域的广泛知识，为你提供了一系列重要的技术。这是一门非常有用的学科，其数据知识来自:

  • 几个来源
  • 规模
  • 类型
  • 结构

随着技术的进步，上述领域被用于数据科学，为其提供适当的方法。

金融硕士

来到金融硕士，这个学位课程为你提供了获得金融专业知识所需的所有知识，是几所大学提供的一个非常常见的学位。具体来说，对于定量分析师来说，金融学位将为你提供数学、计量经济学和编程工具的组合。这些知识帮助一个有抱负的分析师成为一个专业的量化分析师。

完成该领域的学位课程后，您将能够:

  • 将金融相关理论应用于真实的金融市场
  • 将数学应用于金融问题，如预测股票价格
  • 运用经济计量理论分析投资决策

因此，通过选择这一学位课程，你将获得在现实金融世界中重要工具的实际应用的知识。这将有助于培养你在金融市场取得巨大成功的技能。

短期在线课程

有一些简短的在线课程是自定进度和交互式的。此外，你可以选择一些知名平台提供的你想学习的具体方面。Quantra 提供的一些课程有:

交易机器学习入门

一个免费的课程，让你开始学习机器交易。了解不同的机器学习算法如何在金融市场数据上实现。浏览并理解该领域的不同研究。获得这个利基领域的全面概述。

用机器学习交易:回归

本课程非常适合使用机器学习算法创建您的第一个交易策略。循序渐进地学习:获取数据，预处理数据，训练和测试机器学习回归模型，预测股票价格。提供实际操作的编码帮助。

【交易与机器学习:分类与 SVM】

学习在金融市场数据上使用 SVM，并创建自己的预测算法。该课程涵盖分类算法、机器学习中的性能测量、超参数和监督分类器的构建。

神经网络交易中的

本课程强烈推荐程序员和 quants 在金融市场实现神经网络和深度学习。由欧内斯特陈博士提供，学习使用先进的技术，如 LSTM，RNN 在现场交易。

决策树交易中的

通过这门课程，你将学会使用人工智能技术预测市场和寻找交易机会。此外，你将能够训练算法通过数百个技术指标来决定哪个指标在预测正确的市场趋势方面表现最好。进一步，优化这些 AI 模型，学习如何在实盘交易中使用。

执行方案

有了高管课程，你可以从各种专业人士、行业中坚分子那里学到行业的实际方面。

一个这样的高管项目是 EPAT ，这是一个为期 6 个月的综合虚拟课堂项目，涵盖算法交易的基本模块，例如:

  • 市场微观结构
  • 金融工具
  • 统计数字
  • 数据分析
  • 证券管理
  • Python/Matlab/Excel 编码基础
  • 机器学习的使用
  • 交易、技术、基础设施和运营
  • 实时交易策略构建

它通过专注于衍生品、量化交易、电子做市或交易相关技术和风险管理，激励传统交易者走向成功的算法交易生涯。

接下来，我们将看到一个量化分析师的工资/薪酬。

工资/报酬

定量分析师的薪水/报酬是相当丰厚的，因为这份工作的激励性质和要求涉及计算机、金融和数学等学科。

下面，我以表格形式列出了每个国家的平均基本工资:

| 国家 | 平均基本工资 |
|
美国 |
$117,000 |
|
印度 |
卢比 1,427,000 |
|
英国 |
£67,698 |
|
加拿大 |
大约 87，000 美元 |
| 新加坡 | 12 万新元 |
|
香港 |
75 万港元 |
|
澳大利亚 |
10.5 万美元 |

来源:玻璃门

你可以阅读更多关于 quant 的平均工资。

结论

成为定量分析师或定量分析师需要奉献和努力。有了这些知识，定量分析师就能在对冲基金或投资银行获得成功，因为这些公司对定量分析师的需求很高。此外，定量分析师的职业生涯是相当刺激和有益的。

本文中提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害承担任何责任。所有信息均按原样提供。

加密货币的定量数据分析[网络研讨会]

原文：https://blog.quantinsti.com/quantitative-data-analysis-cryptocurrencies-24-february-2022/

https://www.youtube.com/embed/rD7HkJS3yd8?rel=0

完整演示

//www.slideshare.net/slideshow/embed_code/key/nb2FEpp8DvqwhQ

Quantitative Data Analysis of Cryptocurrencies from QuantInsti

Jupyter 笔记本 Python 代码

关于会议

最近有很多关于加密的讨论。如果聊天让你好奇，继续读下去。

在本次网络研讨会中，演讲者将，

  • 探索什么是加密货币，
  • 接触这些天的顶级加密货币，
  • 如何以及在哪里获取加密货币的数据，以及
  • 在那里你可以交易加密货币

她还将分析历史加密数据，并着眼于不同类型的加密交易策略。

扬声器

Udisha Alok (Quant Researcher at QuantInsti)

Udisha Alok(quantin STI 的量化研究员)

Udisha 是 QuantInsti 的一名量化研究员。在此之前，她曾在领先的科技公司担任软件开发员。她对编码和金融市场充满热情。她感兴趣的专业领域是在回溯测试和现场交易中使用机器学习技术。

她写过区块链、比特币、以太坊、Ripple 的文章。正如你可能会告诉，她不能得到足够的加密货币！

本次活动于:
2022 年 2 月 24 日星期四
东部时间上午 8:30 | IST 时间晚上 7:00 |新加坡时间晚上 9:30

成为定量开发人员的简单指南

原文：https://blog.quantinsti.com/quantitative-developer/

由查尼卡·塔卡

定量分析师是定量交易领域另一个有趣的角色。算法交易者和量化开发者之间有很大的不同。算法交易员是在分析市场后执行交易策略的人，而量化分析师是所有算法编程的幕后推手。让我们了解更多关于定量开发人员的信息，正如本文所涵盖的:

谁是 Quant 开发人员？

quant 开发人员是最终在编程语言的帮助下开发策略的程序员。她/他负责为量化交易行业提供金融解决方案。因此，定量开发人员需要对应用数学、统计模型、算法和科学计算有透彻的了解。

量化开发人员通常在投资银行、对冲基金、经纪公司或金融证券公司工作。

接下来，让我们来看看 quant 开发人员的类型。

定量开发人员的类型

在金融领域，主要有两种类型的 quant 开发人员:

  • 前台开发人员
  • 中层开发人员
  • 后台开发人员

前台开发人员

Quant 开发人员与定量分析师一起工作，帮助实施和优化金融模型。这意味着从 Python 等编程语言中获取原型代码，然后用 C++或 Java 等另一种编程语言重写它。前台定量开发人员直接与客户联系，提供定制的软件和分析工具。

中层开发人员

这些是量化开发人员，他们在银行扮演着中间办公室的角色。在投资银行，这意味着在大规模系统上工作。他们参与交易基础设施的编码，帮助定量分析师或交易员运行或执行他们的模型。

后台开发人员

这些开发人员在后台执行诸如模型验证和风险管理等任务。对于这个职位，你需要具备理论知识/技能、分析能力和解决问题的深度。模型验证有助于在后端解决问题，从而进一步避免任何技术问题。

接下来，我们将了解什么资格有助于成为 quant 开发人员。

成为 Quant 开发人员的教育资格

正如我们在定量开发人员的定义中所讨论的，定量开发人员需要精通金融、计算机科学、应用数学、统计模型、算法和科学计算。

一个有抱负的 quant 开发人员必须学习一门编码语言，尤其是最常用的语言，比如 Python ，C++，C#，R 和 Java。

此外，工具的知识是成为一个定量分析师所必需的，因为这些工具有助于回溯测试和最终确定交易策略。本文下面讨论了一些通用工具/平台。

此外，定量金融学是另一门提供分析金融市场和证券所需知识的学科。这种分析基本上是利用数学模型和庞大的数据集来完成的，因此，这一领域的专家被称为定量分析师。

然而，如果一个定量开发人员掌握了关于金融市场和证券定价的知识，能够理解为分析师编写什么样的代码，他/她会在工作中做得更好。

例如，如果定量分析师提出牛市或熊市策略，定量分析师必须了解市场的复杂性以及证券的预测/定价实践。

因此，定量分析师不需要有自己的策略。他们只需要理解并采用策略来完美地自动化它们。

此外，对于大多数金融模型所面临的风险管理来说，掌握风险分析知识也同样重要。

因此，掌握使用定量模型的知识非常重要，这有助于分析师分析过去的数据、当前的数据以及未来的预期数据。

现在让我们找出定量开发人员的工作描述。

作为定量开发人员所需的技能/工作描述

作为一名定量开发人员，如果你全心全意地投入编程，你所承担的角色不仅具有挑战性，而且令人兴奋。

此外，为了成为一名定量开发人员，您必须知道如何从磨练基本技能到掌握高级技能。

下面，我把所有这些技巧都提到如下:

  • 软件开发
  • 通讯技能
  • 理论/技术技能
  • 编程技能
  • 机器学习和深度学习

软件开发

软件开发技能是最重要的技能之一，因为它对于开发人员来说是极其重要的技能，因为它可以帮助您理解开发角色的核心。此外，自动化需要很好的软件开发知识，这种技能在金融领域也很受欢迎。随着你的工作经历的发展，掌握软件开发技能增加了对工作核心的理解。

沟通技巧

对于一个定量开发人员来说，保持良好的沟通技巧/软技巧是非常重要的，这样才能与分析师和其他人进行良好的沟通，从而进行良好的编程。知道如何使用软技能对任何定量开发人员都是有利的，因为它提高了效率，并使任何定量开发人员成功。

理论/技术技能

作为一名量化开发人员，你需要为投资银行或金融服务机构的几个功能开发和维护量化模型。这些功能是定价、风险管理以及分析。为了发展这样的技能和创建这些模型，你需要在统计和数学领域有很强的知识。这些用于定量开发的模型包括:

  • 整合模型
  • 期权定价模型
  • 预测模型
  • 贴现现金流模型
  • 合并模型

整合模型

该模型有助于将多个业务单位整合到一个模型中

期权定价模型

这个模型是基于交易中的 Black-Scholes 和二叉树等理论

预测模型

这个模型有助于预测股票的模式，并在投资股票市场方面做出正确的决策

贴现现金流模型

这个模型对于计算市场中的净现值和未来值非常重要

合并模型

也称为并购模型，它是用主要的合并公司来计算的

编程技巧

下一步是让自己熟悉高效的算法和编程语言知识，如 C/C++、Python、Java 和 MATLAB。这将使你成为金融行业的 bea quant 开发者。

编程技能对 quant 开发人员来说是最重要的，如果你拥有所有其他技能，但不是编程大师，那么你可以在在线学习计划的帮助下随时提高技能。

机器学习和深度学习

有了机器学习和深度学习知识，你将能够实现逻辑回归模型、神经网络、LSTM 以及金融行业的其他 ML 技术。此外，机器学习技术正在进步，并使其在金融领域的每一步都很方便。随着时间的推移，技术和知识的进步有助于定量开发人员在专业水平上发挥作用。

给你一个例子，对于 iRageCapital 的定量开发人员职位，工作职责如下:

  • 开发人员将与我们的定量研究/分析师团队合作，并将协助项目，以改善股票选择，投资组合的建设或实施
  • 此人的主要目标将是围绕开发内部研究平台

所需技能:

  • 强大的编码和数据管理能力
  • 理想的候选人应该具备基本的会计和金融知识
  • 候选人应该有很强的 Python (NumPy，Pandas，Matplotlib，Zipline)/Django/JavaScript 等编码技能。
  • SQL 能力和对关系数据库的理解以及财务/会计的中级知识
  • 可学性、团队精神和灵活性是我们寻找的重要特征

此外，以下是量化开发人员用来开发金融模型和交易策略的工具:

现在，我们来看看定量开发人员的工资/报酬。

工资/报酬

量化开发人员的财务回报/ 薪水是巨大的，这是因为开发人员的工作涉及从了解市场到编码的一切。

下面，我们列出了不同国家定量开发人员的平均工资/薪酬:

|
国家 |
平均基本工资/年 |
美元 |
|
美国 |
$1,24,000 |
$1,24,000 |
|
印度 |
11.14 万卢比 |
$15105.32 |
|
英国 |
£90,898 |
$118495.09 |
|
加拿大 |
大约 9 万美元 |
$68310.90 |
|
新加坡 |
16 万新元 |
$50248.92 |
|

香港 |

1000，000 港元 |

$129024.80 |

来源:玻璃门

你可以阅读更多关于 quant 的平均工资。

尽管上述工资只是每个国家的 quant 开发人员作为新人的平均基本工资的代表。然而，一个专业的定量开发人员除了奖金之外，一年可以赚大约 25 万美元。加上奖金，一个成功的定量开发人员的年薪甚至可以达到 50 万美元。

现在，让我们看看作为一个有抱负的 quant 开发者，你可以采取什么步骤。

成为定量开发人员的步骤

现在，您已经了解了该角色所需的技能以及定量开发人员的工资/报酬，现在您可以看到成为定量开发人员的步骤。在这个子主题中，您将了解如何将技能与行业要求对应起来。这些重要步骤是:

  • 识别和发展技能差距
  • 入围职业机会
  • 准备面试
  • 专业发展

确定和发展技能差距

首先，作为一个有抱负的 quant 开发人员，你需要找出技能的差距，或者在你的道路上缺失的技能。正如你在上面的章节中读到的，你需要一些技术、编程和软件相关的技能以及沟通技巧。最好是找出哪些技能需要挑选和覆盖，以避免任何障碍。

例如，如果你是金融市场出身，从来没有从事过任何技术工作，那么你必须选择那些能为你提供专业知识的课程。

因为建立这些技能是非常重要的，所以你必须注册一门你需要的专业课程。

您可以受益于在线提供的课程，如金融市场中的机器学习和深度学习、使用 Python 的自动交易和期权交易中的量化方法。

入围职业机会

其次，你必须列出可供选择的职业机会，这样你就能找到一个你认为合适的。入围后，你可以开始申请你喜欢的公司的定量开发员职位。以下是雇佣定量开发人员的顶级公司列表:

准备面试

当你渴望成为一名量化开发者时，准备面试是下一步要做的事情。强烈建议您从现有的 quant 开发人员那里获取知识，或者参加 quant 面试问题准备等课程，从而获得专业帮助。如果你准备好一些棘手的面试问题来应对量化面试，效果会好得多。

职业发展

最后但并非最不重要的是职业发展，这意味着即使你有了一份可以依赖的工作，也要时刻保持自我更新。跟上新的机遇，找到在职业上提升自己的方法，这将有助于你提升自己的能力。此外，你将能够为你工作的公司做出杰出的贡献。

结论

定量开发人员的角色分布在多个学科的应用中，如数学、统计模型、算法和科学计算。由于定量开发人员需要为分析师编码并自动执行策略，因此开发人员也必须具备证券和金融市场的所有知识。你还必须具备在银行或对冲基金面试量化开发人员的良好技能。

探索我们关于 Python for trading 的课程，以便利用 Python 编码让你的烛台模式读起来更方便。计算机语言可以帮助你编码，以便对你的烛台模式进行回溯测试，用于数据分析和生成交易信号。

免责声明:本文提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害承担任何责任。所有信息均按原样提供。T3】

数量金融学导论

原文：https://blog.quantinsti.com/quantitative-finance/

由查尼卡·塔卡

在你寻求获得量化金融知识的过程中，如果你想知道从哪里开始，它有什么帮助，那么你必须通读这篇全面的文章。本文分子主题，帮助你详细了解量化金融:

什么是量化金融

简单来说，量化金融提供分析金融市场和证券所需的知识。这种分析基本上是通过使用数学模型和庞大的数据集来完成的，因此，这一领域的专家被称为定量分析师或 quants 。现在，这里有必要提一下，定量分析师使用数学模型是为了:

  • 衍生证券定价
  • 风险管理。

此外，定量分析师专门设计、开发和实现解决复杂金融问题的算法。现在让我们向前看，并找出为什么定量金融是重要的。

量化金融有多重要？

量化金融是你学习成为量化分析师所需的一切的核心。虽然对于有抱负的量化分析师来说，学习量化金融很重要，但事实上，很多精通交易知识的人来自各种背景。

据观察，2017-2018 年，报名参加量化金融学习课程的参与者中有 60%没有金融背景。

因此，如果你有金融背景，这很好，但如果没有，你可以轻松报名参加学位课程或证书课程。

成为量化分析师后，对量化金融的深入研究可以在一些广泛的领域帮助你:

  • 投资组合管理
  • 货币市场

投资组合管理

看到投资组合管理的各种优势，将你的投资组合分散到股票、债券、衍生品和大宗商品中是至关重要的。作为一名基金经理，你需要研究不同资产类别在一个群体中的表现以及它们之间的关系。因此，有了定量金融的良好知识，你可以研究各种资产类别的价格运动模式。通过这项研究，你可以分析资产价格的变动并增加收益。

货币市场

在货币市场上有很多关于债券收益率和货币走势的投机活动。因此，定量金融的恰当使用导致对各种风险的估计和对冲。此外，它还能帮助你找出你应该在市场上以特定价格买入的资产数量。

由于这两个类别可以让你获得经济上有回报的工作，我们在本文后面提到了一些其他有回报和有趣的工作，你可以从事定量分析师的工作。

现在，让我们看看什么样的资格能让你更接近成为量化分析师的目标。

成为量化分析师需要什么资格？

当你渴望成为量化分析师或定量分析师时，你需要选择合适的资格，这就是为什么我们在这里为你列出了一些学位和证书课程:

学位课程

有一些学位课程可供你选择，让你成为量化分析师的愿望变成现实。你可以根据你的兴趣和背景从列表中选择一个你认为合适的学位课程。看看为你入围的学位课程:

金融工程硕士

由于金融工程硕士课程为你提供了从评估统计数据到经济计量模型的深入知识，这是一门在现实世界中帮助你的工程课程。当你获得定量分析的专业知识时，你就可以自信地完成这篇文章。在学习本课程的过程中，您将在以下重要主题的背景下获得全面的金融知识:

  • 统计数字
  • 数学
  • 计算机科学

总之，在这样一个快节奏的世界里，这门课程将使你具备在需要特殊工作的专业环境中取得成功的正确知识。

金融数学硕士

这个学位让你深入了解定量金融的方法论。因为它是面向金融数学的，你将具备所有你需要的知识，以便在以后进入定量分析领域。本课程旨在使你作为一名定量分析师熟练掌握金融数学的实际应用。还有，学完这门课，你将能够根据定量分析做出逻辑结论。您可以在本课程中学习的一些科目(必修和选修)包括:

  • 布莱克和斯科尔斯理论
  • 随机分析
  • 最优投资组合选择
  • 派生物
  • 马尔可夫过程
  • 金融风险分析
  • 国际融资
  • 时间序列分析预测及其他。

由于上面的一些科目是必修的，所以还有一些是选修的，这样你就可以更容易地选择那些你认为对你以后的生活很有必要的科目。这个选择也取决于你之前是否已经学过这些科目。

数据科学硕士

在这个学位课程中，你将学习所有关于数据科学的知识，基本上可以帮助你将统计学、数据分析和机器学习联系起来。一旦你掌握了所有这些领域和相关的概念，你就可以将所学学科的复杂性用于实际应用。随着广泛的知识，从各个领域，如数学，统计学，计算机科学和信息科学，这个学位课程为您提供了一个重要的技术组合。这是一门非常有用的学科，其数据知识来自:

  • 几个来源
  • 规模
  • 类型和
  • 结构。

随着技术的进步，上述领域被用于数据科学，为其提供适当的方法。

数学与计算金融硕士

这门学位课程旨在为学习者提供全面的数学背景知识。这些知识为你提供了解决金融数学问题所需的技能。它围绕着金融行业的需求和应对这些需求的技能。由于这是一门专门为让你掌握数学概念和计算金融知识而设计的课程，它将帮助你实现 apt 工具。有了这个学位课程，你可以从事定量分析师的工作，并在这方面出类拔萃。这个学位课程中的各种概念包括偏微分方程，概率和统计，金融市场和 Python。

应用经济学硕士

正如本课程的标题所言，它为学习者提供了经济学和计量经济学的综合知识。本课程涵盖了经济学的高级知识，旨在为您提供以下方面的深刻见解:

  • 应用微观经济学
  • 宏观经济学
  • 计量经济学和
  • 战略决策

当你渴望成为定量分析的专家时，应用经济学将在给你额外的专业知识方面发挥巨大的作用。对于那些已经获得经济学领域的基础知识并渴望在这个领域继续前进的人来说，这是最好的学位课程。如果你希望获得数学、统计学和计量经济学方面的高级知识，那么这门课程将有助于你在特定领域变得熟练。

金融硕士

来到金融硕士，这个学位课程为你提供了获得金融专业知识所需的所有知识。具体来说，对于定量分析师档案，金融学位将为你提供数学，计量经济学和编程工具的组合。这些知识帮助一个有抱负的分析师成为一名专业的量化分析师。

完成该领域的学位课程后，您将能够:

  • 将金融相关理论应用于真实的金融市场
  • 将数学应用于金融问题，如预测股票价格
  • 运用经济计量理论分析投资决策

因此，通过选择这一学位课程，你将获得在现实金融世界中重要工具的实际应用的知识。这将有助于培养你在金融市场取得巨大成功的技能。

好了。我们已经看到了所有著名的学位课程，现在是时候进一步探索一些证书课程了。

证书课程

有一些量化金融方面的证书课程可以帮助你提升你的职业和技能。无论你是在寻找帮助你开始职业生涯的东西，还是在职业生涯中期提升专业技能，证书课程都能满足你的需求。在这里，你会发现一些有用的证书课程，我们已经入围:

应用金融风险管理专业证书课程

这个证书课程是专门为了让你更熟练的金融风险管理。与管理金融风险所需的工具和技术的知识，这个证书课程将会给你一个非常重要的技能，需要在金融世界的功能。它将把重点放在金融机构风险管理实践的创建和实施上。通过本课程，你将获得数学和算法领域的必要知识，从而能够分析市场风险。而且，随着 apt 技术的学习，你将有足够的技能来构建和管理风险管理策略。通过本课程，您将学会:

  • 掌握风险和回报之间关系的诀窍
  • 理解激励对风险管理的影响
  • 管理在度量和管理风险时出现的基本挑战
  • 构建和实施测量和管理金融风险的工具和技术。

如果你想从“风险管理”的角度提升自己作为量化分析师的技能，那么本课程将帮助你在努力中向前迈进一步。

金融证量化研究

因为作为一个量化分析师，你需要在数学和统计知识上领先一步，所以这个课程可以帮助你做到这一点。本课程帮助您熟练掌握算法和投资理念。该量化金融证书旨在提高您在以下方面的技能:

  • 数学和统计学
  • 金融市场中的定量分析
  • 投资相关算法和技术

总而言之，这个证书课程旨在提高你在量化金融及其在金融市场中的功能的技能。

量化基础证书

正如证书课程的名称所示，它旨在为您提供量化金融领域所需工具的全面知识。通过本课程，您将深入了解:

  • 量化金融
  • 金融市场
  • 投资行业

因为你将获得数学、统计学、R 编程和经济学基础的技能和专业知识，这个课程将帮助你在现实世界的金融环境中发挥你的最佳水平。因此，要想成为一名专业人士，并准备好作为一名定量分析师面对金融世界，这个课程应该能很好地服务于你的目的。

数据科学硕士

正如我们在上面的学位课程中提到的数据科学硕士，这个证书课程只是提升你在数据科学领域的技能。该课程涉及数学、统计学、计算机科学和信息科学等领域，旨在帮助您熟练掌握:

  • 研究和分析市场趋势
  • 做出建模决策
  • 测试新模型
  • 维护和修改分析模型

有了这个证书课程，你将学会上述技能和更多。

好吧！因此，我们已经提到了所有的学位课程和证书课程，你可以选择，同时渴望成为一名定量分析师或在你的指定方面更有技能，让我们继续看更多。未来，我们将会看到在量化金融领域，以及一旦你成为一名专业的“定量分析师”，你可以从事的所有工作。

量化金融领域的工作

因为你作为一个定量分析师的范围很广，这里我们简单地提到了可以考虑的工作概况。此外，新闻报道表明，随着技术的进步，需要能够利用技术分析金融市场的定量分析师。

如果你还记得，我们在开始时讨论过，定量分析师利用数据来分析市场，然后设计算法模型来解决复杂的金融问题。因此，有了所有的数据和技术来分析它，并围绕它建立算法模型，作为一名定量分析师或定量分析师，你一定会为自己开辟一条非凡的道路。

据《经济时报》报道，到 2022 年，印度的数据消费量预计将增长 72.6%，达到 1096587.93 亿 MB。随着如此大规模的数据生成，公司将需要能够发现模式和趋势、建立模型、预测、预报和解释这些数据结果的专业人员。

事不宜迟，让我们看看定量分析师或量化分析师的所有职业选择:

风险管理

作为风险管理的专业人员，定量分析师或定量分析师构建模型或技术，以便更好地分析金融市场的风险。无论是与投资相关的风险还是与交易头寸相关的风险，量化分析师都有足够的技能来分析风险，但与风险分析师不同。此外，定量分析师构建了各种风险管理工具，用于在特定情况下实施每种工具。

前台 quant

前台定量分析师是参与销售和交易等操作的定量分析师。在这种情况下，工作职责包括处理销售和交易，并为交易者确定有利可图的机会。为了增加利润，量化分析师需要在交易策略中运用量化方法。

算法交易

算法交易是将交易策略转换成计算机代码的过程，计算机代码以自动、快速和准确的方式买卖股票。Quants 主要负责开发交易的复杂算法。

图书馆定量分析

在这样的职位描述中，定量分析师需要分析和验证已经存在的模型。我们需要这些模型来提供相关信息，而这种职位描述中的定量分析师会确保这些模型能够提供相关信息。

此外，要了解量化分析师的薪水，请点击此处阅读。你一定已经看到，作为一个定量分析师或定量分析师，有一个广泛的范围，正确的学位或证书课程和合适的工作简介可以帮助你建立一个伟大的职业生涯。

结论

在这篇文章中，我们涵盖了从学位课程到证书课程和工作简介的量化金融的所有内容。这篇文章旨在帮助你理解什么是量化金融，以及你进入这个领域后所能获得的机会。作为一名定量分析师，在选择合适的职业时，你面前有很多选择。由于有各种职业道路可供选择，作为定量分析师的专业人士有足够的机会。

免责声明:本文中提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害承担任何责任。所有信息均按原样提供。

量化投资分析师如何学习量化投资组合管理

原文：https://blog.quantinsti.com/quantitative-investment-analyst-quantitative-portfolio-management-quantra-success-story-esuabom-dijemeni/

“对于一个量化投资分析师来说，思考和头脑风暴来制作一个模型比编写模型本身更重要”——esu abom Dijemeni

在偶然发现了许多学习量化金融的渠道后，Esuabom 来到了 Quantra。以提高他的技能并对领域有更清晰的了解。

这是 Esuabom，分享他的旅程和经历。

大家好，我是 Esuabom Dijemeni，目前在英国。我在法国巴黎银行做量化投资分析师。

我之前是做医疗科技的，现在转行做 fintech 了。我不是那种上过商学院、拥有商学学位的典型定量分析师，由于这一点，提高技能和不断学习变得更加重要。

我是一个热衷于学习的人，并且有这个习惯去参加与我相关的在线课程。我一直在学习量化金融领域跨平台的多门课程，以不断学习和提高我的技能，这将给我带来额外的优势。

我想要一门纯粹从数量角度学习概念的课程。我给了 Quantra 一个机会看看这对我是否有价值。我选择了量化投资组合管理课程，因为我发现它最适合我，而且到目前为止我一直很喜欢它。

我从这门课中最大的收获是对概念的解释，从某种意义上说，这是看待这件事的另一种方式。我喜欢这样的课程，它能让你以稍微不同的方式看待事物。我从这门课中学到的是制作模型背后的思维和技巧。额外提供的 PDF 文档是额外的奖励，我确保我阅读了它们，因为它们再次允许我从不同的角度探索我已经熟悉的概念。

对于一个量化投资分析师来说，思考和头脑风暴做一个模型比编码模型本身更重要。这段代码确实帮助我理解了模型背后的技术。

我注意到其他平台更侧重于实现，但 Quantra 更侧重于解释，这正是我所寻找的。例如，现代投资组合理论无法像 Quantra 那样在任何其他平台上得到解释。其他人展示如何编码模型，而 Quantra 实际上花时间解释它。

聪明的量化分析师能够通过数据和回溯测试结果来影响投资决策。我觉得 Quantra 课程一定会帮助用户成为聪明的 quantr。

你的话让我们受宠若惊，伊苏邦。谢谢你。很高兴去过那里，为你提供合适的学习资源和指导，能够指导你的学习。我们祝你未来一切顺利。

量化投资组合管理推荐给那些希望量化构建投资组合，产生回报，有效管理风险的人。在本课程中，您将学习不同的投资组合管理技术，如因素投资、风险平价和凯利投资组合，以及现代投资组合理论。对于那些有志开始，现在注册！

免责声明:为了帮助正在考虑从事算法和量化交易的个人，这个成功的故事是根据 Quantra 的一个学生的个人经历整理的。成功案例仅用于说明目的，不用于投资目的。完成 Quantra 课程后获得的结果可能不会因人而异。T3】

Prodipta Ghosh 的量化投资组合管理策略

原文：https://blog.quantinsti.com/quantitative-portfolio-webinar-23-july-2019/

https://www.youtube.com/embed/u5UUjHZQCFk?rel=0

23 日星期二路【2019 年 7 月
美国东部时间上午 10:00 | IST 时间晚上 7:30 |新加坡时间晚上 10:00

  • 应该投资哪里？
  • 要冒多大的风险？
  • 如何降低投资组合波动性？

每个交易者每天都会遇到一些不可避免的问题，量化投资组合管理不仅简化了这些问题的解决方案，还允许你在不同的策略中优化配置资本。QuantInsti 为您带来了对 Prodipta Ghosh 的独家采访，他将分享他的见解和一些交易技巧。

面试大纲

  • 购买股票和创建投资组合的区别？
  • 一个人应该如何做投资决策？
  • 如何优化投资组合以获得更好的回报？
  • 如何识别和最小化风险？

还有更多...

演讲者简介

prodipta-ghosh

Prodipta 领导 QuantInsti 的 Fin-tech 产品和平台开发。

他是一名经验丰富的量化分析师&在加入 QuantInsti 之前，他在银行业工作了十多年——在伦敦孟买的德意志银行担任过各种交易和结构部门的职务，并在渣打银行担任公司银行家。在此之前，普罗迪塔在印度国防研发组织(DRDO)担任科学家。

他毕业于 Jadavpur 大学，获得机械工程学士学位，并拥有 IIM 勒克瑙大学的管理学研究生学位。

//www.slideshare.net/slideshow/embed_code/key/dCzQ3N4MGZUpCB

Quantitative Portfolio Management Strategies by Prodipta Ghosh from QuantInsti

有关我们所有网络研讨会的完整列表，请查看 此链接

对于我们所有的 powerpoint 幻灯片，请访问我们的幻灯片共享页面 这里 。

量化交易——建立入门思路和思路流程

原文：https://blog.quantinsti.com/quantitative-trading-building-entry-ideas/

扎克·奥克斯

我最喜欢的作者之一凯文·戴维(Kevin Davey)宣扬了一个他称之为“策略工厂”的想法——虽然这个过程的所有部分对盈利策略的制定都至关重要，但如果没有原始投入(或新的交易想法)，你将会极大地限制你的产出。那么，即使在你似乎已经测试并优化了你认为可行的每一个入口组合之后，你如何保持想法的流动呢？让我们看看。

在本文中，我们将介绍:

自动交易的一个关键部分是想法的产生，通过保持事情简单，你可以通过改善输入来大大提高输出。做到这一点的一个简单方法是让战略的一些可变方面保持不变——比如使用固定的退出方案——并在开始时只关注新的进入。

通过优化战略发展的过程，你可以创造一个新鲜的，独特的信号不断输出，可以结合起来，大大提高你的表现。

那么，我们如何保持想法流动？对我来说，我设定了每周必须测试的新想法的门槛——为了保持信号的持续流入。这些并不总是最初的伟大想法，但有时它们会激发伟大的想法或对现有事物的改进。我试着每周创造 5 个有机进入信号。

让我对条目多讲一点——最初，我有一个通用的退出包(TrailStop，Fixed Stop，Boolean Target ),我称之为信号退出；基本上只是出场逻辑的延伸。

用一个例子来解释更容易，如果我在 5 日均线穿过 20 日均线时做多，也许我的做多信号出口是在 5 日均线有负斜率时，或者当它们都是负斜率时，或者当 5 日均线低于 20 日均线时，如果只是做多。

结合我的一般退出包——百分比止损、固定止损和布尔利润目标——我基本上可以复制粘贴到我的退出包中，调整进场逻辑，我就可以开始测试策略了。

我这样做有几个原因:

  1. 效率——它能让我保持思路畅通。有时我会添加一个新的退出信号的想法，并把它作为那周我的 5 个独特想法之一。但大多数时候，我坚持使用我的通用退出包。
  2. 一致性——通过保留标准的退出包，我能够以一种快速(多图表性能报告)的方式比较进入信号的有效性。

出口被处理了，所以我可以专注于入口——我的想法流现在只依赖于入口信号。那么，在我测试了所有合理的技术、基本面和这些信号的组合之后，我在哪里产生这些进场的想法呢？

我是一个技术人员，所以我承认我对价格行为有偏好，但对我来说，我总是喜欢看图表来寻找新的进场想法。我让自己沉浸在一个符号中，然后改变时间框架，或者在同一张图表上配对几个时间框架，也许添加一两个指标，看看它是否给我展示了什么新的东西。

  • 一旦我得到一些看起来可能是可重复模式的东西，
  • 我在图表上寻找一些心理条目。
  • 我试图找到例子来证明我的信号是错误的，也就是说进场信号表现很差。
  • 然后，我会看看是否有一个不同的区间，一个额外的指标，或者一些 OHLC 模式可以把这个坏的条目从组合中去掉。
  • 我寻找过滤器，使我发现的模式更加可靠。

记住，要想有一个有效的策略，你不想过多地限制你的交易；你需要一个坚实的条目数量，这不仅是为了增加更大超额收益的可能性，也是为了增加你的样本量和统计显著性。

如果你一个月有一笔交易，你很容易连续 5 笔交易亏损 6 个月。如果你大约每小时有一笔交易，如果你还在 6 个月的亏损中交易，那么你比我更勇敢。

当我在图表中看不到任何新的东西时，我该去哪里呢？我有几个最喜欢的信号想法，如果你给他们一个机会，我保证你会大大提高你的想法流。

  • 我浏览流行的图表标记，新的指标想法，寻找我没有像其他人那样经常交易的符号，浏览我在宏观层面上注意到的普遍情绪或偏见。也许每隔一个图表是一个比特币到 50k 的图表，也许我不同意，可以利用这一点。
  • 股票和商品的技术分析:(杂志，或者网站——Traders.com)这是我绝对喜欢的一个。你不仅会得到新鲜的图表和观点，而且它们总是有一个新的指标(或对旧指标的新看法)。
    他们有不同的市场和符号，这总是有助于开发一个新的想法。大多数问题实际上都有一个策略，可以转换到你熟悉的任何平台上。
    从这里开始，看看它是否能给你一些不同的想法。
  • 书籍:我从真的旧的交易书籍中找到很多新的想法；我特别喜欢拉里·威廉姆斯或比尔·威廉姆斯的作品。他们在这里有一些永恒的模式，虽然从技术的角度来看这不是一个新鲜的视角，但他们经常提供不同的视角。这些旧书中有许多是完整的瑰宝，新书也非常有用(Bean、Chan、Davey、Prado、Pruitt 是我最喜欢的作者)。
  • 归档:当我在开发一个新策略时，如果它不完全符合我的预期，但仍然有利可图，我会将它归档。我将它和它的性能指标一起保存在一个大数据库中，以便以后我可以带着新的东西回来。
    如果我在寻找一个新的想法，我有时会从那些看起来不太可行的策略开始，看看我是否错过了什么。老实说，我已经能够改进我存档的大多数策略，只要稍后带着新的见解回来。改进后，并不是所有的都符合我的要求，但是很多都符合！没有什么比挽救一个几乎被扔进垃圾桶的改良回收项目更好的了。
    我还鼓励你回顾一下你现有的“强大”策略列表，看看你是否能改进那些已经符合你的规格的策略。

重要的不是你在哪里发现新想法，而是你持续不断地产生新想法。这些资源激励我寻找新的进入方式，但是你的可能完全不同！

我还想澄清一点，这不是一部印第安纳·琼斯电影，我们也不是在这里寻找圣杯——我们的目标是产生超额回报的新策略，以及与现有阿尔法模型的 负相关 。

如果你把足够多的这些信号结合起来，它很有可能成为一个革命性系统的组成部分。不过有一点是肯定的，如果不尝试新的(或循环的)想法，你的阿尔法技能将永远不会增长。把自己放在那里；创造一些新的大胆的东西，你永远不知道——它可能是你的** 圣杯系统中的一个成分。**

结论

虽然新的想法是你持续发展的原材料，但有许多方法可以提高底线，例如，增加新的、稳健的交易策略。我发现即使是最好的策略也往往非常简单。

虽然没有人知道 RenTec 的信号是什么样的，但我想至少它们都是以非常简单的方式开始的。它们都必须从某个地方开始，我鼓励你也这样做，牢记这些目标。

编辑注:QuantInsti 尊重作者的选择和偏好，但我们绝不认可、支持或建议本文中的任何品牌。这些观点完全是作者的观点。我们更喜欢并提倡使用 Python 进行量化交易。T3】

免责声明:本文提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害负责。所有信息均按原样提供。

用深度强化学习进化量化交易

原文：https://blog.quantinsti.com/quantitative-trading-deep-reinforcement-learning-quantra-success-story-mattia-mosolo/

你是否一直希望与时俱进，提升自己的交易水平，培养在市场中有效交易的信心？

你想在你的交易中实现像机器学习或深度强化学习这样的现代技术方法吗？

你不确定你是否能做到，或者不知道如何去做？

Mattia 也是，直到他找到了让这一切成为可能的方法。以下是他如何使之成为可能的。

Mattia Mosolo photo

嗨！我是 Mattia Mosolo，来自意大利。我一直在寻找优秀的交易方式。

但是，我并不总是一个交易者。几年前，我对金融市场产生了兴趣，学习了技术和基本面分析。我认为机器学习(ML)是实施定量策略的最佳解决方案，因此在过去的八个月里我一直在认真地研究它。

我是在探索 Youtube 和互联网上其他相关渠道的免费资源时接触到深度强化学习的。然而，我想用结构化的方法更深入地研究定量金融。就在那时，我偶然发现了 Quantra 提供的‘交易中的深度强化学习’课程，并报了名。

起初，我很惊讶地看到视频很短！我几乎觉得内容不好。但是当我学习这门课程时，我意识到这是一种非常有效的学习方式！这些简短(但清晰)且切中要点的视频之后，紧接着是一系列测验来检查你的学习情况。

教学大纲中的 Jupyter 笔记本帮助我实际应用这些主题。因为我现在可以终身学习该课程，所以重温它有助于我更好地理解管理数据和数据标准化的概念。

我在不同的数据集上做了课程中提供的顶点工程，发现它非常有用。我采用欧元-美元数据，并减少样本数据大小，以减少训练时间。

我更改了学习率、ε率、最小ε率和相关参数，这样就不用花几个小时来训练数据。我下载了欧元-美元外汇对，因为这是一个有效的市场。结果我完成了项目，却没有看到解决方案。

Quantra 社区也让这个课程变得容易理解，因为它帮助我在一天之内澄清了所有的问题和疑虑。这让我的学习更加顺利。

总而言之，我对深度强化学习课程的体验非常好。现在我对强化学习的正确结构有了理解。我也必须对我的交易做更多的改进。

接下来，我期待着学习神经网络，同时尝试使用深度强化学习建立一个定量模型。

课程结束时，我意识到这是正确的学习方法。我对自己的决定很满意。感谢你的精彩课程，Quantra。

谢谢你的美言，马蒂亚。我们很高兴看到你在课程中惊人的学习和成长。我们很高兴您在 Quantra 获得了很好的学习体验，并从我们的课程中受益匪浅。

你的交易之旅从一个强烈的兴趣开始，发展到这种程度，真是不可思议。我们祝愿你在未来的努力中一切顺利。

像 Mattia 一样，如果你也希望学习定量分析回报和风险，并应用强化学习来创建、回溯测试、纸上交易和现场交易一个使用两个深度学习神经网络和重放记忆的策略，请务必查看我们的交易课程中的深度强化学习。

免责声明:为了帮助正在考虑从事算法和量化交易的个人，这个成功的故事是根据 Quantra 的一个学生的个人经历整理的。成功案例仅用于说明目的，不用于投资目的。完成 Quantra 课程后获得的结果可能不会因人而异。T3】

在 R 中使用 Quantstrat 软件包的量化交易策略:一步一步指南

原文：https://blog.quantinsti.com/quantitative-trading-strategy-using-r/

在本帖中，我们将使用 R 构建一个交易策略。在深入研究使用 R 的交易术语之前，让我们花一些时间来理解 R 是什么。r 是开源的。目前有超过 4000 个附加包，18000 多个 LinkedIn 群组成员和近 80 个 R Meetup 群组。这是一个完美的统计分析工具，尤其是数据分析。全面 R 档案网络的简明设置为 CRAN 提供了软件包列表以及所需的基本安装。根据需要进行的分析，有许多可用的软件包。为了实现交易策略，我们将使用名为 quantstrat 的软件包。

任何基本交易策略的四步流程

  1. 假设形成
  2. 测试
  3. 改善
  4. 生产

我们的假设被表述为“市场是均值回归的”。均值回归(Mean reversion)是一种理论，认为价格最终会回到平均值。第二步是测试假设，我们根据假设制定策略，并计算指标、信号和绩效指标。测试阶段可以分为三个步骤，获取数据、编写策略和分析输出。在这个例子中，我们考虑漂亮的蜜蜂。它是由高盛管理的一只 T2 交易所交易基金。NSE 具有巨大的仪器体积，因此我们考虑这一点。下图显示了相同的开盘价-最高价-最低价-收盘价。

我们设定了一个阈值来比较价格的波动。如果价格上升/下降，我们更新阈值列。收盘价与高波段和低波段进行比较。当穿过上带时，这是卖出的信号。同样，当穿越较低波段时，是买入信号。

编码段可以概括如下，

  • 添加指标
  • 添加信号
  • 添加规则

下图给出了该策略输出的俯视图。

因此，我们的假设，市场是均值回复是支持的。因为这是回溯测试，所以我们有空间改进交易参数，提高我们的平均回报和实现的利润。这可以通过设置不同的阈值水平、更严格的进场规则、止损等来实现。人们可以选择更多的数据进行回溯测试，使用贝叶斯方法设置阈值，将波动性考虑在内。

一旦你对回溯测试结果支持的交易策略有信心，你就可以进入实时交易了。生产环境本身是一个很大的话题，超出了本文的范围。简单来说，这需要在一个交易平台上编写策略。

如前所述，我们将使用 quantstrat 包构建模型。Quantstrat 提供了一个通用的基础架构，用于对基于信号的量化策略进行建模和回溯测试。它是一个高层次的抽象层(建立在 xts、FinancialInstrument、记事本等之上。)允许您用很少几行代码来构建和测试策略。

quant strat 的主要特点是，

  • 支持包括指标、信号和规则的策略
  • 允许将策略应用于多资产投资组合
  • 支持市价、限价、止损和止损追踪订单类型
  • 支持订单规模和参数优化

在这篇文章中，我们建立了一个包括指标、信号和规则的策略。

对于一般的基于信号的模型，以下是应该考虑的对象，

  • 工具-包含市场数据
  • 指标-来自市场数据的量化值
  • 信号——市场数据和指标相互作用的结果
  • 规则——利用市场数据、指标和信号生成订单。

事不宜迟，让我们讨论编码部分。我们更喜欢使用 R studio 进行编码，并坚持让你使用相同的。在对策略进行编程之前，您需要安装某些软件包。

下面一组命令安装必要的软件包。

install.packages("quantstrat", repos="http://R-Forge.R-project.org")
install.packages("blotter", repos="http://R-Forge.R-project.org")
install.packages("FinancialInstrument", repos="http://R-Forge.R-project.org")

安装完软件包后，您可以导入它们以备将来使用。

require(quantstrat)

从 csv 文件中读取数据并将其转换为 xts 对象。

ym_xts

我们用股票、货币、初始权益和策略类型初始化投资组合。

stock.str='NSEI' # stock we trying it on
currency('INR')
stock(stock.str,currency='INR',multiplier=1)
initEq=1000
initDate = index(NSEI[1])#should always be before/start of data
#Declare mandatory names to be used
portfolio.st='MeanRev'
account.st='MeanRev'
initPortf(portfolio.st,symbols=stock.str, initDate=initDate)
initAcct(account.st,portfolios='MeanRev', initDate=initDate)
initOrders(portfolio=portfolio.st,initDate=initDate)

如果你想在同一边交易不止一次，增加仓位限制。

addPosLimit(portfolio.st, stock.str, initDate, 1, 1 )

创建策略对象。

stratMR

我们建立一个函数来计算我们想要交易的阈值。如果价格变动超过阈值 1，我们将阈值更新为新价格。交易的新波段是阈值+/-阈值 2。输出是一个 xts 对象，尽管我们使用了重分类函数来确保。

THTFunc<-function(CompTh=NSEI,Thresh=6, Thresh2=3){
numRow(tht+Thresh)){ tht<-xa[i]}
   if(xa[i]<(tht-Thresh)){ tht<-xa[i]}
   xb[i]

添加指标、信号和交易规则。

stratMR

运行策略，看看订单簿。

out<-try(applyStrategy(strategy=stratMR , portfolios='MeanRev') )
# look at the order book
getOrderBook('MeanRev')
end_t<-Sys.time()

更新投资组合并查看交易统计数据

updatePortf('MeanRev', stock.str)
chart.Posn(Portfolio='MeanRev',Symbol=stock.str)
tradeStats('MeanRev', stock.str)
View(t(tradeStats('MeanRev')))
.Th2 = c(.3,.4)
.Th1 = c(.5,.6)
require(foreach)
require(doParallel)
registerDoParallel(cores=2)
stratMR<-add.distribution(stratMR,paramset.label='THTFunc',component.type= 'indicator',component.label = 'THTT',
                         variable = list(Thresh = .Th1),label = 'THTT1')
stratMR<-add.distribution(stratMR,paramset.label='THTFunc',component.type= 'indicator',component.label = 'THTT',
                         variable = list(Thresh2 = .Th2),label = 'THTT2')
results<-apply.paramset(stratMR, paramset.label='THTFunc', portfolio.st=portfolio.st, account.st=account.st, nsamples=4, verbose=TRUE)
stats

这是完整的代码

require(quantstrat)
ym_xts (tht+Thresh)){ tht<-xa[i]}
   if(xa[i]<(tht-Thresh)){ tht<-xa[i]}
   xb[i]

下一步

一旦你熟悉了这些基础知识，你可以看看如何在 R 中开始使用 quantimod 包。或者如果你擅长 C++，看看用 C++ 编码的策略的例子。

如果你是一名散户交易者或专业技术人员，想要建立自己的自动化交易平台，今天就开始学习算法交易吧！从基本概念开始，如自动交易架构、市场微观结构、策略回溯测试系统和订单管理系统。

免责声明:股票市场的所有投资和交易都有风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。

使用情绪分析的量化交易

原文：https://blog.quantinsti.com/quantitative-trading-using-sentiment-analysis-webinar/

https://www.youtube.com/embed/JAk20F2IWJ4?rel=0

日期和时间

2016 年 6 月 28 日星期二

格林威治时间下午 04:00 |美国东部时间下午 12:00 | IST 时间下午 09:30

关于情感分析

情感分析。也称为观点挖掘，是对一段文本中表达的观点进行计算识别和分类的过程，尤其是为了确定作者对特定主题、产品等的态度。是正的、负的或中性的。分析发现，社交媒体、股票市场、法律、政策制定、社会学甚至客户服务都有显著的突出之处。

会话内容

  • 情感分析如何工作
  • 使用情绪分析设计交易策略
  • 盈利能力的历史分析-案例研究
  • 使用情感分析的陷阱以及如何避免它们

建议阅读

发言人简介

Rajib-Ranjan-Borah

Rajib Ranjan Borah，伊拉克资本咨询公司联合创始人

Rajib 为亚洲交易所设计高频交易策略，并与其他交易所和机构合作设计教育项目。他曾应邀在各种会议上发言，如 2015 年 7 月在伦敦举行的“UChicago Quant 交易大会”和“第五届年会:行为模型&情绪分析应用于金融”，关于美洲、欧洲和亚洲的情绪分析和高频交易。

他拥有印度管理学院(Indian Institute of Management Calcutta)的研究生管理学位、印度国家理工学院(National Institute of Technology Surathkal)的计算机工程学士学位，以及在纽约彭博公司(股票期权衍生品研究)和首诺国际(Solutia)的 EMEA 战略总部的实习经历。

automated trader logo该网上研讨会还出现在自动交易商的“事件页面上

Python 中的量化价值投资策略

原文：https://blog.quantinsti.com/quantitative-value-investing-strategy-python/

由伊山沙阿

价值投资的起源可以追溯到本杰明·格拉哈姆所著的《证券分析》和《聪明的投资者》( T2 ),在书中，他提倡对基本面指标进行详细分析，以购买股价低于其内在价值的股票。沃伦·巴菲特，本杰明·格拉哈姆最著名的学生之一，向我们所有人展示了价值投资产生更高回报的力量。

Python Handbook

投资价值股与成长股

根据 Brandes 的一项研究，价值投资在很长一段时间内大大超过了市场和成长型股票。

Stock Classification

他们使用简单的估值指标，如市盈率、市净率和市盈率来识别价值股和成长股。【1】

使用的一种方法是按市净率对所有股票进行分类，然后将前 10%的股票归类为成长股，后 10%的股票归类为价值股。他们观察到，在连续 5 年的时间里，价值股的表现要比成长股好得多。

Value Stocks vs. Growth Stocks

价值在更多的时期和更长的时间里跑赢了增长(魅力)【2】

然而，我认为价值投资者进行的许多分析——阅读财务报表和评估相对估值——可以通过自动化流程更快、更有效地完成，而且可以覆盖更广泛的证券类别。量化价值投资策略是一种识别最稳健的长期价值型股票的努力。

接近

量化价值投资策略方法可以用以下方式定义:

  1. 识别全套股票
  2. 筛选价值和质量
  3. 坚定投资

从小盘股到大盘股定义了一个完整的股票列表，低流动性和交易限制的股票被排除在外。然后基于各种量化基本面参数进行筛选，形成最便宜的优质股票组合。让我们看看如何在 Python 中实现这一点。

注意:为了演示这个练习，我定义了一个潜在股票的小列表。你也可以使用整个标准普尔 500 列表。

导入库

第一步是导入必要的库，即 pandas，yahoo_fin。

量子力学、金融和现在的算法交易|古斯塔沃的故事

原文：https://blog.quantinsti.com/quantum-mechanics-finance-epat-success-story-gustavo-correa/

51 岁的 EPATian Gustavo Corrêa 来自南非约翰内斯堡。他有超过 25 年的丰富工作经验，他喜欢称之为他的人生经历。

Gustavo 已经获得了量子力学硕士和金融工程硕士学位，并获得了多项认证以提高技能。

从他在巴西度过的童年到他目前在南非作为算法交易者的生活，Gustavo 分享了他不可思议的算法交易之旅。

嗨，古斯塔沃，给我们介绍一下你自己吧！

你好。我的名字是古斯塔沃·科雷亚。我出生在南美洲的巴西，并在那里长大。我现在住在南非，因为我母亲是南非人，我于 1998 年搬到这里。

我在巴西学习物理，然后攻读量子力学硕士学位，只是因为我热爱科学和数学的客观一面。后来，这对我走上算法交易的道路有很大的影响。

教学是我的爱好之一，我一直在教书。分享知识和再次体验知识的能力，学习的快乐，总是非常独特的。当你教某人时，你加入了那个人的学习和发现之旅，以及有了更深理解的喜悦。

我记得我在巴西上大学的第一年，老师们是如何罢工的。我们不能浪费时间，所以班里的每个人都聚在一起，在我们之间分配科目，然后准备课程互相教授。我已经准备了微积分、物理甚至经典力学的课程。

在获得量子力学硕士学位后，我开始在巴西教授计算机动画，当我搬到南非时，我开办了一所计算机动画学校。

我是天主教徒，目前，我还在我的儿童学校教授宗教教育。对我来说，这是一条完全不同但令人兴奋的道路，因为它涉及形而上学、哲学和神学，谈论道德和成为一个更好的人的整个想法。

物理、金融和现在的算法交易，你是怎么做到的？

我第一次遇到全权委托交易，你可以自己设计和实施策略，而不用电脑。你有足够的工具用于交易。你必须了解市场动向，这完全取决于你的专业知识和识别机会的注意力。

生活只是通过发现自主交易把我带到了一个新的方向，然后很明显，我自己试图通过书籍、视频和任何我能找到的材料来学习。

然后我发现了算法交易，你可以实际创建一个程序，不仅可以执行你的策略，还可以根据你可以遵循的合理的统计原则，事先制定策略。这对我来说太不可思议了，因为我一直热爱编程和数学，现在我正跳入一个涵盖两者的领域。

意识到你可以用电脑进行交易，制定策略，实施和管理策略，打开了一条全新的途径，因为你可以用电脑处理更多的数据。

Algo 交易是编程的结合，是数学和统计的联盟，很适合我的物理背景。成功驾驭市场并不困难。

它引起了我的兴趣，因为它是数学、统计学、编程和数据分析。我喜欢数字。但我从未想过或计划从事金融行业。

我觉得算法交易需要一个人投入时间和精力。我联系了 EPAT 大学以前的校友雅克·儒贝尔，他也来自南非。通过他，我了解了算法交易(EPAT)的高管项目。很快，我就能识别出两种途径的优势:理论上的和实践上的。

金融工程硕士学位将提供强大的理论背景。

另一方面，EPAT 教你实现交易愿景所需的理论和实践，它提供了令人难以置信的实践经验。你可以接触到行业人士，分享他们的经验。

因此，我决定在获得金融硕士学位后，参加 EPAT 认证项目。

作为一个理科出身的人，你觉得学习算法交易有挑战性吗？

我认为在你想学习的任何领域，你都可以深入其中，无论你来自哪里，它都仍然具有挑战性。

我想说，我的金融工程背景在算法交易的一般概念方面给了我很大帮助。也涉及到一些编程，但是有这个基础指导我学习编码。由此，我能够建造 EPAT 提供的积木。

EPAT 的主题非常广泛，它为你提供了几种选择。你可以稍后深入到一个特定的领域，比如 HFT 或机器学习。

我可以说，我发现 EPAT 课程非常有趣和具有挑战性。

EPAT 和这些年的自学相比有多大的不同？

在线学习的最大风险是它最终会变成一个人的事情。你把材料放在网上，你去看，检查，阅读，完成任务，然而这对于一些学习科目来说可能并不理想。对一些人来说，这可能行得通，对另一些人来说，这可能行不通。

但在 EPAT，我们有现场讲座，你可以实时参与讲座，你甚至可以提出问题，并直接从该领域最优秀的教师那里获得答案。

这就像一个经典的例子，你坐在一个正在授课的老师面前。这些现场讲座对课程的惊人质量至关重要。我确实有讲座的录音以防错过，但参加现场讲座总是最好的选择。

EPAT 的 LMS(在线学习平台)也很棒，因为你可以访问课程材料、笔记、讲座等等。

因此，尽管它是一个在线学习平台，但它的互动方式让人感觉不像是单向关系，而是一种共生关系。

你最喜欢 EPAT 的哪个特色？

教员和支持经理都很有帮助。我不断收到来自安置团队的电子邮件，这是 EPAT 的一个精彩而强大的特色。但是有些事情我想指出来。

首先，我要指出的是，EPAT 是一所来自印度的学校，因此这些人可能会有负面偏见，说你宁愿去美国、英国或德国学习。但这完全忽略了一点:在这个时代，伟大的东西可以来自世界任何地方，EPAT 肯定是其中之一。

其次，师资力量一流。讲师来自世界各地，这是它成为真正世界级课程的原因。

所以，不要被“印度能带来什么好处”的想法所欺骗。！。看看我，我是一个巴西人，从印度，一路从南非，学习世界级的算法交易课程。

你对想学习算法交易的学生有什么话要说？

我想说有两个因素——一个是你完全可以控制的，另一个是你几乎无法控制的。

在参加 EPAT 课程的时候，如果你全身心地投入其中，并且努力学习，这本身就是一个成功的故事。你会学到的。你会知道一切的。

在 EPAT 之后，你将拥有成为算法交易者所需的所有工具、技能和知识。这是我可以向你保证的结果，你可以完全控制，因为这取决于你自己。一切都在那里，如何充分利用就看你自己了。

但是，当需要制定策略并运用你所学的算法交易时，会有挑战，因为现在你是在和现实世界打交道，而你对现实世界几乎没有控制权！

完成 EPAT 课程后，你肯定会更有能力获得成功，但成功需要时间和耐心。再说一遍，这完全取决于你的奉献精神:诚实地对待你所学到的东西，并将其应用于实践。

这真的很鼓舞人心，谢谢你和我们分享你不可思议的旅程，古斯塔沃。正如你所说，这些都是生活经历，我们希望我们的读者能与你的故事联系起来。我们祝愿你在未来的事业中一切顺利。

如果你也想用终生的技能来武装自己，这将永远帮助你提升你的交易策略。这门 algo 交易课程的主题包括统计学和计量经济学、金融计算和技术以及机器学习，确保你精通在交易领域取得成功所需的每一项技能。现在就来看看 EPAT 吧！

免责声明:为了帮助那些正在考虑从事算法和量化交易的人，这个成功的故事是根据 QuantInsti EPAT 项目的学生或校友的个人经历整理的。成功案例仅用于说明目的，不用于投资目的。EPAT 方案完成后取得的成果对所有人来说可能不尽相同。T3】

关于算法交易的最常见问题

原文：https://blog.quantinsti.com/questions-algorithmic-trading/

由维拉伊·巴加

关于算法交易已经说了很多，也写了很多。尽管网上有介绍 T2 的视频和指南，但只有像 T4、EPAT、T6 这样真正旨在把人变成专业人士的课程很少。

这篇文章列出了一些与算法交易最相关的问题。这些是很多人在 AMA 的算法交易会议上提出的，这个会议提供了一个开放的平台，让他们的问题得到行业巨头的解答。你也可以看看这篇关于的文章，关于 Algo 交易你不知道的 7 件事。

但是，与人类的智力相比，所有这些都要小得多，人类的智力会产生无数的问题，这是因为人类的天性非常好奇和探索。为什么不应该呢？提问是我们的天性。人们经常面临与算法交易相关的问题，并努力寻找正确的答案和解决方案。在我们讨论算法交易的常见问题之前，这里有一些问题可以让我们对它有一个清晰的了解:

今天 Algo 交易是怎么回事？

  • 75%的全球交易是通过算法执行的。
  • 印度交易所 35-40%的交易额通过算法交易【1】
  • 与众多机构投资者、个人投资者、交易者等一起实现跳跃式增长。

为什么选择算法交易？

Why Algorithmic trading

交易最常用的算法有哪些？

在印度，使用应用编程接口(API) 的算法是最常用的。在这里，投资者选择策略，然后他编程并由经纪人执行。【2】

什么影响算法交易？

What affects Algo trading

但这并没有停止。这就是你应该知道的算法交易。以下是我们在算法交易的中遇到的一些最常见的问题。问题的范围从基础到一些真正有趣和专业的问题。

看着这些问题，你可能会有似曾相识的感觉，并想…“我以前没想过这个问题吗？”如果没有，你可能会想“为什么我以前没有想到这一点？”

**所以，现在开始:

算法交易常见问题

Q1。 What is delay?

回复:延迟是你在发出一个订单的时候，你损失了多少时间。基本上，它是订单到达交易目的地或交易所所用的时间，或者是处理市场数据、订单路由等所用的时间。

潜伏期帮助你确定合适的基础设施将建立你自己的办公桌。这也有助于你确定你是应该选择基于势头的策略还是做市策略。一旦您知道您的策略可以适应什么样的延迟，所有这些问题都变得容易回答了。

我们把所有不同的交易策略模式的所有概念和潜伏期混在了一起。

定义之外:频率交易有哪些类型？

LFT (低频交易)——如果你的交易策略可以适应半秒或一秒的延迟，而性能不会太差，我们可以称之为低频交易

MFT (中频交易)——如果你的策略不能适应那么多，但仍能适应几十毫秒的延迟，那么你就在谈论中频交易策略

HFT (高频交易)——如果你的策略承受不起哪怕 1 微秒的不利，那就意味着我们正在进入高频交易的游戏

Q2。 Is it true that HFT/ algorithm traders usually beat manual day traders? Therefore, if the regular trading decreases below a certain threshold, which market will HFT/ algorithm lose interest in? If yes, what is the threshold?

回复:说高频交易 (HFT)普遍击败手动日内交易者并不绝对真实，这都要看我们这里说的是什么样的日内交易者。如果你说的是从套利机会或市场低效中获利的日内交易者，那么是的，机器可以更快地做这些事情。

举例来说，如果你是一个优秀的手工交易者，你可以在一秒钟内发送一个订单，如果你真的很优秀，那么可能在一秒钟内发送 2 个订单，如果你是“超人”，那么可能在一秒钟内发送 3-4 个订单，但不能超过这个时间。而另一方面，机器通常受到交易所设定的节流率的限制。

一台机器可以在一秒钟内发送成千上万的订单，所以这里没有匹配，但如果我们谈论的是那些分析数据并以手动方式执行订单的交易员，但他们进行了更多的研究，做了大量的功课，那么没有，这无关紧要。

关于门槛问题的第二部分，我们所看到的是，高频交易量参与越大，参与者的数量就越多，例如，如果你看看发达市场的交易所，如纽约证券交易所(NYSE) 你将能够看到，在一些交易所中，几乎 80-85%的交易量是通过算法发生的，大多数 HFT 公司专注于这些市场。在任何门槛的情况下，所有的 HFT 公司都将消失。发展中市场的情况也是如此，在印度也是如此，主要交易所中近 45-50%的交易量发生在算法上，尤其是在衍生品方面。

所以算法的使用并没有减少。如果算法太多，HFTs 将会失控，这是不正确的。竞争将会升温，一些高频交易将会倒闭，一些将会继续存在，但仅此而已。

Q3。 What if the market over-trades algo? Will it backfire?

回复:这又是上一个问题的延伸。市场会不会适得其反？不尽然！

当你说算法时，它本质上意味着你已经自动化了执行，算法并不总是意味着高频交易。因此，如果你是一个散户，你使用任何一家经纪商提供的 API 进行交易，你并不是真正在高频基础上交易，因此你不是 HFT，但你肯定是 algo，它只是带来了更高的效率。

如果有太多的算法，你试图交易市场中的低效率，那么这可能是一个挑战，因为找到这些效率可能真的很难，但除此之外，它不会适得其反。另一点需要补充的是，即使对于效率低下的企业，瞄准它们也变成了一场技术和基础设施的游戏。所以这些因素给了你一定的优势。

例如，您可以拥有的网络类型、系统类型、不断变得更加昂贵的硬件。

因此，如果你专注于吃掉市场的低效率，而不是市场中的 HFT，就很难发现低效率，因为它在那里的那一刻，就消失了，有人会把它拿走。

Q4。 Can I quantify the technical indicators? How about patterns and waves?

回复:是的，你可以量化的技术指标，这很简单，因为这是一套数学公式，无论是否量化，都可以看出来。但是你绝对可以量化和自动化它们。

是的，你也可以量化模式和波形。相对容易得多的模式；如果你能想到什么，那么机器就有能力去做，因为就像我们的大脑一样，机器也是基于逻辑工作的。详细说明一下，当你编写逻辑代码时，有些算法可能会更复杂，而有些算法可能很容易编写。

举个例子，如果你在画一条趋势线，那就相当简单了，你在找两个点，y=mx+c 就是你的趋势线公式，如果你知道截距，你就可以画一条线，或者如果你知道这两个点，你就可以计算截距并画一条线。这部分并不难，你可以计算出局部最大值和局部最小值，然后你就可以画线了。如果你在看一些有很大主观空间的东西，那就更难了。

同样，在波浪方面，如果你试图编写一个艾略特波浪代码，并且非常明确地定义了波浪规则，那么这并不困难，但是如果你为主观性留了很多空间，那么，在这种情况下，这将变得非常困难。事实上，有一些工具可以用来编码这些波的模式，我们也已经开始研究这样的东西，在不久的将来你应该可以看到。

Q5。 I am a LARP businessman in Western Australia; Now that there is ready-made software, do I need to learn algo?

回复:这完全取决于什么对你有效。如果现成的软件已经在为你工作了，并且你对它的性能感到满意，那么你只需要继续发展和试验，因为同样的东西不会一直工作。

Q6。 Does automation help overcome emotional defects in transactions?

回复:肯定！事实上，这是自动化你的战略的好处之一。

控制情绪，给你可伸缩性，给你带宽，当执行由机器执行时，你可以用它来制定策略，这些都是任何规模的自动化带来的主要好处。

除非你一直在干扰你的端口，否则什么也帮不了你，但假设你不这么做，那么自动化可以帮上忙。

Q7。 Is HFT suitable for retail investors? Is the algorithm for retail investors?

回复:是针对散户的算法交易？可能是的，如果你有正确的技能。

但散户投资者肯定不会选择 HFT，因为 HFT 更像是一场科技游戏。如果有人说你现在是散户，你可以去 HFT，不要被误导。如果这个人不知道 HFT 到底是什么意思，或者他不知道散户是什么意思。

在你开始交易 HFT 策略之前，你需要花费合理的资金。这并不意味着你不能做 algo，algo 你可以。

但如果你计划利用零售平台进行现金期货套利、日历价差或一些基本的看跌期权套利，那么你可能不会看到太多的成功。

Q8。 Can C++ language be used for algorithm trading? Is Java important in algorithm trading?

回复:在大多数 HFT 公司，如果你在高频率和低延迟方面 C++ 是首选语言，因为它是最快的，你关心每一微秒。如果你不担心这一点，那么你可以使用任何其他语言，这没关系，它不会增加那么多你应该担心的延迟。所以是的，可以用 C++语言。

能是唯一能用的吗？如果你在做 HFT，那么最有可能是，否则不是。

另一件需要知道的重要事情是，这些编程语言不仅仅是编码算法或策略，它还有助于进行大量的研究和分析，所以这是 R 和 Python 中更受欢迎的东西。即使在 HFT 测试中，你也会看到很多分析师使用 R 和 Python 进行回溯测试，评估交易策略。当它投入生产时，算法是用 C++为 HFT 编码的。但是对于中频和低频，任何语言都可以。

Q9。 I trade a system with a hit rate of 45%, and the average profit/average loss =1.75. Trading is 2-3 times a month, but sometimes there will be 2 losses or even 7 consecutive losses. This particular difficulty prevents me from increasing the trading volume, even if the capital is positive. Can you come up with a solution?

回复:这只是这里有限的信息，但我怀疑或猜测的是后验测试参数或输出参数中有问题，那里可能有一些优化的空间。

在量化交易策略中，你会看到交易比率以及不同的比率，其中包括每个交易者都会看到的一个基本情况，那就是亏损。因此，样本内和样本外交易有一个基本但不太流行的概念，那就是，你不要优化对你可用的整个数据集的回溯测试，你要对样本内和样本外数据进行回溯测试。在样本内数据中，您可以进行所有想要进行的优化，然后在未经优化的样本外数据上运行策略，并检查性能如何，或者在您的情况下，下降情况如何。如果提取太多，那么你需要在你的策略中增加一点波动性，这对于一个风险来说太高了，如果它显示的结果在样本外数据中造成了巨大的损失。因此，这是可以帮助你的东西，你可能会在扩大你的战略中获得一些信心。

Q10。 How do we know if a market/trading place is saturated in HFT/ algorithm trading? For example, As an HFT company, I am considering entering a new market. How important is the existing HFT ratio in this market to me?

回复:正如我们之前讨论的，HFT 比率只是告诉你可以预期的竞争程度。如果你的策略是简单的普通套利策略，那么 HFT 比率表明进入这个市场可能不是一个好主意。如果你的策略不是简单的普通套利策略，而是更聪明，使用更多的数据分析结果，使用更多的统计数据进行一些像样的预测，那么，在这种情况下，它可能就没那么重要了。

高 HFT 绝对意味着，如果你想冒险进入普通的套利策略，甚至在一定程度上进入做市策略，你需要有一个技术非常强大的基础设施。

Q11。 What is the exact meaning of total bid quantity and total asking price quantity? Who are those who will buy but haven't bought and sold yet, and vice versa, and their numbers will be counted. Who has bought but not yet sold, and vice versa, these figures will be counted.

回复:总买价数量和总卖价数量仅仅是人们可以购买和出售的东西，它并没有给你多少交易的指示。它只是告诉你市场的情况，好吧，有这么多的人在那里买这么多数量的东西，他们在那里买，在那里卖。

Q12。 In India, after HFT traders entered the T2 T1 market, did the traditional trading volume decrease?

回复:肯定的，是的。

在印度，曾经有一些大型自营交易公司雇佣 500-1000 名交易员，这些人不停地进进出出。批发商是这里的俗称。

这些交易者不会过多地分析屏幕，但会建仓，并试图在几秒或几分钟内退出。此外，在进行大量的套利策略之前，所有这些东西都非常流行，但在 algos 中，所有这些东西都非常容易被机器取代，所以这就是所发生的事情。这些类型的公司不得不收缩，但是他们中的大多数已经改变了他们的策略和商业模式，更多的转向的面向的方面。这就是我们在印度看到的变化。

Q13。 I am a software professional from the background of data science. How soon can I make a simple algorithm?

回复:我认为从算法交易的角度来看，这是一个相当强大的背景。我假设你已经很好地掌握了统计学和编程，现在你需要选择量化交易。因此，如果你对统计数字有很好的理解，这应该相对容易，但仍取决于你在金融市场方面的出发点。我不能回答需要多少个月，但是你已经得到了 3 个月中的 2 个，所以优先权在你这边。

Q14。 Is the basic index data manually entered into the program?

****回复:如果你谈论的是市盈率或典型的基本面，如增长和宏观经济数据(如 GDP)，你可以手动输入，也可以使用数据软件输入。有些公司确实会向你提供数据(机器可读的经济数据)，所以你可以输入这些数据，当数据发布时，算法会读取你的数据，你可以根据结果对你的策略进行预编码，并相应地发送订单。因此，所有这些都是可能的，在零售领域并不常见，但现在有一些工具也可以用于零售。有些工具还可以直接读取或抓取新闻或网络上的数据。

Q15。 What are the advantages and disadvantages of HFT from India for non-Indian market?

****回复:这将更多地落在娱乐方面，而不是其他方面。毫无疑问，作为一名印度人，你不能把钱拿出去交易外汇交易所上市的保证金产品。除非你有 RBI 的批准，我不认为你可以这样做。但是，如果有一家公司(全球公司)将其交易外包给你，那么你可能可以，但我不确定。我可以肯定的一点是，你不能寄钱，你可以寄钱投资，但你不能寄钱交易保证金。

Q16。 After HFT enters the market, will the trading place worry about losing the retail trading volume?

****回复:绝对不会！

我不知道这方面的任何经验证据，因为散户一般不做套利。散户确实建仓；他们购买股票，进行商品交易。大多数情况下，他们通常采取方向性押注，但如果市场上没有高频交易，那么散户投资者支付的买卖价差将相对较高。

如果有高频交易，那么市场将会更有效率，这意味着它们支付的买卖差价将会小得多。事实上，Aite Group(HFT 领域的领先分析机构)在大约 2 年前的一项研究中提到，仅仅因为高频和算法交易带来的更好的买卖价格，一个普通的美国散户交易者就可以节省将近 250 美元。

在 HFT 的存在下，市场的流动性要高得多，因为 HFT 拥有技术和基础设施，可以降低缩小市场的风险因素。万一发生一些剧烈的事情，比如经济中的重大变化，特别是股票结果，管理决策，诸如此类的事情，高频交易者可以更快地做出反应。他们有信心，因为他们有能力在 99.99%的时间里创造更窄的市场，如果你增加减速带，或者剥夺高频交易者的信心或舒适，情况就不是这样了。所以，这就是为什么当你有 HFT 时，你会看到更紧张的市场，否则买卖价差会更高。

Q17。 Flash novels depict HFT as immoral. Do you agree with this view? Should a system with higher computing power give you the right to fight Xiao Qiao?

****回复:如果你发现有人在做违法或不符合规则或法规的事情，那么这显然是不正确的，也是不应该发生的，这与金融市场、电子商务、高频交易或基金管理等领域无关。

“ Little Joe ”通常会说很多关于支付的过渡成本，因为那里有很多高频交易。高频交易夺走了套利机会，因为它们提高了市场效率。就我个人的观点而言，散户交易者不会因为 HFT 的所作所为而受到伤害，HFT 相对于中频交易公司、经纪人或零售商的优势是微乎其微的。

散户通过基于网络的浏览器发送订单，这意味着他们已经有几毫秒的延迟，所以你作为散户不会受到影响。如果一家 HFT 公司在做任何事情，获得非法访问是另一回事，但即使在这种情况下，我也怀疑散户是否会受到伤害，因为首当其冲的将是遵守规则的其他 HFT 公司，非法访问将让他们有几微秒的优势，这对其他 HFT 公司来说是一件大事，但对散户来说不是。

即使在主机托管设施的情况下，我也有几毫秒的优势，这并没有什么不道德的，如果你把我放在离市场 100-200 英里的地方，那么我肯定会损失一些时间，但我会相应地将我的报价设置得更宽。

Q18。 How many hours does a quantitative analyst spend on coding every day?

回复:这取决于你是什么样的量化分析师，但通常是一天中的大部分时间。它将是 R 和 Python 的混合；它可以是 C++或者其他语言。世界上有大量的语言。一些平台有多种语言，而他们中的一些也会创建一个基于 VB 脚本的模型。语言可能有所不同，但编码的数量可能相当可观。

Q19。 What are the different types of algorithms that can be used for automatic transactions?

****回复:有很多；同样，您必须根据低频、中频和高频来滤除它们。

在高频率的情况下，重点将更多地放在套利和做市以及一些定向策略上，这将需要大量更快的计算。

在中低频端，你可以从自动化的角度自动化任何策略。使用因子模型，你甚至可以自动化你的基本面投资来分析和实现算法。不知道你会从中受益多少，但从分析的角度来看，你会受益匪浅，因为你可以浏览许多年度报告和许多股票的许多基本面数据，这是你无法手动完成的，但从执行的角度来看，这并没有多大帮助。关键是你可以自动化各种策略。

比较流行的有基于动量的策略，统计套利，基于希腊的期权策略，分散和基于情绪的策略。有一个关于自动交易的流行策略的完整列表，是的，我们也涵盖了很多网络交流。

Q20。 How does Algo trading help retail investors?

****回复:从接收者的角度来看，如果你是手动操作，而有人在做 algo，那么你的收益就是买卖价格和流动市场。如果你想用算法进行自己的交易，这种情况下，它会给你更多的规模和股票数量，你可以在这些股票上运行每种策略。因此，你可以手动操作 5 到 10 只股票或 5 到 10 只策略，而不是去监控它们。此外，情感力量和分析方面可以用算法创造很多奇迹，即使你没有用算法做执行部分。

Q21。 I'm an NRI, trading in India through PIS platform. How do I do algorithmic trading?

****回复:如果你是一个 NRI 你可以做算法交易，这应该不成问题，你需要与能够满足 NRIs 的合适的经纪人联系，我认为大多数经纪人都能够做到这一点。如果你不是印度人，而你想在印度做生意，那么你可以以 FPI 类别 3 的身份来。

自动化是允许的，但有一些限制性股票你不能投资，但那是很小的一部分。

下一步

我们很确定，你也会有一些问题要问我们，我们很乐意帮助你解决这些问题。如果你在算法交易生涯中需要任何进一步的指导，请随时 联系我们 。如果你是一个交易者、程序员、学生或者其他想从事算法交易的人，那么我们有算法交易的执行课程( EPAT )给你。

QuantInsti 帮助人们获得适用于各种交易工具和平台的技能。EPAT 就是这么做的。其全面的课程包括培训模块，如统计学和计量经济学，金融计算和技术，算法和量化交易，并装备你成为一名成功的交易者。点击 了解更多 。

免责声明:本文中提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害承担任何责任。所有信息均按原样提供。**

最佳实践:用正确的方式写作！

原文：https://blog.quantinsti.com/r-best-practices-r-you-writing-the-r-way/

由米林德·帕拉德卡

任何程序员在日常工作中都不可避免地要编写大量代码。然而，并不是所有的程序员都养成了写清晰代码的习惯，这些代码很容易被其他人理解。原因之一可能是程序员缺乏对编写程序时遵循的最佳实践的认识。对于程序员新手来说尤其如此。在这篇文章中，我们列出了一些 R 编程的最佳实践，它们将提高代码的可读性、一致性和可重复性。请继续阅读！

在 R 中写作的最佳实践

1)描述你的代码——当你开始编码时，在第一行描述 R 代码做什么。对于随后的代码块，遵循描述代码块的相同方法。这使得其他人很容易理解和使用代码。

举例:

# This code captures the 52-week high effect in stocks
# Code developed by Milind Paradkar

2)加载包–在第一行描述完你的代码后，使用库函数列出并加载执行你的代码所需的所有相关包。

举例:

library(quantmod);  library(zoo); library(xts);
library(PerformanceAnalytics); library(timeSeries); library(lubridate);

使用更新的包–在编写代码时，确保你使用的是最新更新的 R 包。要检查任何 R 包的版本，可以使用 packageVersion 函数。

举例:

packageVersion("TTR")
[1] ‘0.23.1’

4)将所有源文件组织在同一个目录中—将您的代码中使用/来源的所有必要文件存储在同一个目录中。您可以使用各自的相对路径来访问它们。

举例:

# Reading file using relative path
df = read.csv(file = "NIFTY.csv", header = TRUE)
# Reading file using full path
df =  read.csv(file = "C:/Users/Documents/NIFTY.csv", header = TRUE)

5)使用一致的数据结构类型—R 编程语言允许不同的数据结构，如向量、因子、数据帧、矩阵和列表。对特定类型的数据结构使用类似的命名。这将使识别代码中使用的相似数据结构变得容易，并容易发现问题。

示例:您可以通过添加来命名代码中使用的所有不同的数据帧。df 作为后缀。

aapl.df   = as.data.frame(read.csv(file = "AAPL.csv", header = TRUE))
amzn.df = as.data.frame(read.csv(file = "AMZN.csv", header = TRUE))
csco.df  = as.data.frame(read.csv(file = "CSCO.csv", header = TRUE))

缩进你的代码–缩进让你的代码更容易阅读，尤其是当有多个嵌套语句时，比如 For-loop 和 if 语句。

举例:

# Computing the Profit & Loss (PL) and the Equity
dt$PL = numeric(nrow(dt))
for (i in 1:nrow(dt)){
   if (dt$Signal[i] == 1) {dt$PL[i+1] = dt$Close[i+1] - dt$Close[i]}
   if (dt$Signal[i] == -1){dt$PL[i+1] = dt$Close[i] - dt$Close[i+1]}
}

7)删除临时对象–对于运行在数千行代码中的长代码来说，在临时对象在代码中发挥作用后删除它们是一个好的做法。这可以确保 R 不会变成内存问题。

8)为代码计时–您可以使用 system.time 功能为代码计时。您还可以使用相同的函数来找出不同代码块所用的时间。该函数返回计算表达式或代码块所花费的时间(秒)。计时代码将有助于找出任何瓶颈，并通过对脚本进行必要的修改来帮助加速您的代码。

为了找出不同块所用的时间，我们在 system.time 函数的调用中将它们用花括号括起来。

该函数返回的两个重要指标包括:I)用户时间——代码向 CPU 收取的时间；ii)运行时间——执行整个代码所用的时间

例如:

# Generating random numbers
system.time({
mean_1 = rnorm(1e+06, mean = 0, sd = 0.8)
})

user    system    elapsed
0.40      0.00       0.45

9)使用矢量化—矢量化可以加快代码的执行速度，尤其是在处理大型数据集时。可以使用 ifelse 语句或 with 函数之类的语句进行矢量化。

举例:考虑一下俏皮的 1 年期价格系列。让我们使用两种方法(使用 for-loop 和 with 函数)找到每天的缺口，并使用 system.time 函数对它们计时。请注意执行 for 循环所用的时间，以及执行 with 函数和 lagpad 函数所用的时间。

library(quantmod)
# Using FOR Loop
system.time({
df = read.csv("NIFTY.csv")
df = df[,c(1,3:6)]
df$GapOpen = double(nrow(df))
for ( i in 2:nrow(df)) {
df$GapOpen[i] = round(Delt(df$CLOSE[i-1],df$OPEN[i])*100,2)
}
print(head(df))
})


# Using with function + lagpad, instead of FOR Loop
system.time({
df = read.csv("NIFTY.csv")
df = dt[,c(1,3:6)]

lagpad = function(x, k) {
c(rep(NA, k), x)[1 : length(x)]
}

df$PrevClose = lagpad(df$CLOSE, 1)
df$GapOpen_ = with(df, round(Delt(df$PrevClose,df$OPEN)*100,2))
print(head(df))
})

10)折叠代码–折叠代码是 R 程序员可以折叠代码行或代码段的一种方式。这允许在需要时隐藏代码块，并使浏览冗长的代码变得更容易。代码折叠可以通过两种方式完成:I)代码的自动折叠 ii)用户定义的代码折叠

自动折叠代码: RStudio 自动提供折叠代码的灵活性。当程序员编写函数或条件块时，RStudio 会自动创建可折叠的代码。

用户自定义代码折叠:用户也可以通过使用编辑- >折叠- >折叠或简单地选择一组代码并按下 Alt+L 键来折叠任意一组代码。

用户定义的折叠也可以通过代码段来完成:要插入一个新的代码段，可以使用代码- >插入段命令。或者，任何包含至少四个尾随破折号(-)、等号(=)或井号(#)的注释行将自动创建一个代码段。

11)严格审查和测试你的代码—一旦你的代码准备好了，确保你在不同的输入参数上严格测试它。确保 for-loop、if 语句、ifelse 语句等语句中使用的逻辑是正确的。让你的同事审查你的代码以确保工作的高质量是一个好主意。

12)不要保存你的工作空间****–当你想退出时，它会检查你是否想保存你的工作空间。建议不要保存工作区，并在一个干净的工作区中开始下一个 R 会话。来自先前 R 会话的对象可能导致难以调试的错误。

这些是用 R 编写的一些最佳实践，你可以遵循它们来使你的代码易于阅读、调试并确保一致性。

下一步

“高位做空”是项目工作中制定的策略之一。这篇文章简要解释了这个策略和编码部分。

免责声明:股票市场的所有投资和交易都涉及风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。T3】

I B- I brokers R 包的体系结构解释

原文：https://blog.quantinsti.com/r-implementation-in-interactive-brokers-api/

Architecture Explained of R Package for IB - IBrokers

由米林德·帕拉德卡

在上一篇关于使用 IBrokers 包的文章中，我们向读者介绍了 IBrokers 包的一些基本功能，这些功能用于通过 R 检索市场数据、查看账户信息以及执行/修改订单。这篇文章将介绍 IBrokers 包的结构，该包将使 R 用户能够构建他们的定制交易策略，并通过交互式经纪人交易工作站(TWS)执行这些策略。

交互式经纪人 API 架构概述

在我们解释 IBrokers 包的底层结构之前，让我们先来概述一下交互式代理 API 架构。Interactive Brokers 提供了可以在 Windows、Linux 和 MacOS 上运行的 API 程序。API 与 IB TWS 建立连接。反过来，TWS 连接到 IB 数据中心，因此，所有通信都通过 TWS 路由。

IBrokers R 包使用户能够用 R 编写他的策略，并通过 IB TWS 帮助它执行。下面是流程结构图。Overview of the Interactive Brokers API ArchitectureT2】

从 TWS 获取数据

为了从 IB TWS 中检索数据，IBrokers R 包包括五个重要的函数。

  • reqContractDetails:检索详细的产品信息。
  • reqMktData:检索实时市场数据。
  • reqMktDepth:检索实时订单簿数据。
  • reqRealTimeBars:检索实时 OHLC 数据。
  • reqHistoricalData:检索历史数据。

除了这些功能之外，还有帮助功能，使用户能够容易地创建上述数据功能。这些助手功能包括:

  • twsContract:创建一个通用协定对象。
  • tws quality/tws STK:用于创建权益合同对象的包装程序
  • twsOption/twsOPT:用于创建选项协定对象的包装。
  • twsFuture/twsFUT:创建期货合同对象的包装程序。
  • twsFuture/twsFOP:创建期货期权合约对象的包装程序。
  • twsCurrency/twsCASH:用于创建货币合约对象的包装程序。

举例:

tws = twsConnect()
reqMktData(tws, twsSTK("AAPL"))

Getting data from the TWS

实时数据模型结构

当使用数据函数访问市场数据流时，TWS API 接收到的数据流遵循特定的路径，该路径能够将这些数据流存储到相关的消息类型中。下面显示的是 reqMktData 函数的参数列表。

示例:reqMktData 函数的参数

T2】

来源:R -马尔科姆·谢灵顿的算法交易

实时数据模型

在下面的小节中，我们将看到这个数据模型是如何工作的，以及如何定制实时数据函数(例如 reqMktData)的参数来创建 r 中用户定义的自动交易程序。

使用回调参数

像 reqMktData、reqMktDepth 和 reqRealTimeBars 这样的数据函数都有一个特殊的回调参数。默认情况下，该参数从 IBrokers 包中调用 twsCALLBACK 函数。

twsCALLBACK 函数的一般逻辑是从 TWS 接收每个传入消息的标头。然后将它与 eWrapper 对象一起传递给 processMsg 函数。eWrapper 对象可以维护状态数据(价格)，并具有管理来自 TWS 的所有传入消息类型的函数。一旦 processMsg 调用返回，就会出现另一个无限循环。

在下面显示的传入消息示例中，我们用绿色圈出了一条消息(1 6 1 4 140.76 1 0)。第一个数字(即 1)是报头，其余数字(即 6 1 4 140.76 1 0)构成了消息的正文。

来自函数 reqMktData 调用的传入消息

根据消息类型，收到的每条消息都将调用适当命名的 eWrapper 回调。默认情况下，如果没有指定，代码将调用默认方法，通过 cat 将结果打印到屏幕上。

默认方法示例:

Default MethodT2】

结果:

Result

设置 CALLBACK = NULL 会将原始消息级数据发送到 cat，cat 又会使用该函数的 file 参数将数据返回到标准输出，或者通过打开的连接、文件或管道进行重定向。

回调参数设置为空的示例:

CALLBACK argument set to NULLT2】

结果: Result

回调，通过回调和事件包装器，被设计为允许实时数据流的 R 级处理。回调有助于定制输出(即输入的结果)，该输出可用于根据用户定义的标准在 R 中创建自动交易程序。

tw callback 函数的内部代码

回调函数(即 twsCALLBACK 函数)内部是一个循环，它获取传入的消息类型，并在每个新消息时调用 processMsg 函数。

Internal code of the twsCALLBACK functiontwcallback 函数的内部代码片段

ProcessMsg 函数

processMsg 函数内部是一系列 if-else 语句，这些语句根据已知的传入消息类型进行分支。processMsg 函数的内部代码结构片段如下所示。

The ProcessMsg FunctionprocessMsg 函数的内部代码片段

eWrapper 关闭

The eWrapper Closure使用 eWrapper 函数在 twsCALLBACK 中创建 eWrapper 闭包

eWrapper 函数创建一个 eWrapper 闭包，以允许自定义的传入消息管理。eWrapper 闭包包含一个函数列表，用于管理所有传入的消息类型。每个消息在 eWrapper 中都有一个对应的函数，用于处理每个传入消息类型的特定细节。

eWrapper 闭包中包含的函数列表

数据环境是。数据，用访问器方法获取。数据，赋值。这些方法可以从闭包对象 eWrapper\(get 中调用。数据，eWrapper\)assign。数据等。通过创建一个 eWrapper 实例，并以函数调用的方式调用它，可以修改嵌入在对象中的任何或所有特定方法。

总结****I brokers 包的内部结构

我们已经在上面看到了 IBrokers 包的内部结构是如何工作的。总结整个机制，可以描述如下:

向 TWS 请求数据->tw callback->processMsg->eWrapper

实时数据模型

我们将使用 Jeff Ryan 发布的 snapShotTest 代码示例。下面的代码修改了 twsCALLBACK 函数。这个修改后的回调用作 reqMktData 函数的参数。当我们使用 reqMktData 函数时，使用修改后的回调的输出比普通输出更便于阅读。【T2Real-Time Data Model

snapShotTest 代码中的另一个变化是将来自 IB API 的任何错误消息记录到一个单独的文件中。(在默认方法下，eWrapper 将此类错误消息打印到控制台)。为此，我们使用 eWrapper 创建了一个不同的包装器(debug=NULL)。一旦我们构建了它，我们就可以将它的 errorMessage()函数分配给我们应该使用的 eWrapper。

simple trade logic

然后，我们应用一个简单的交易逻辑，如果最后的买入价高于预先设定的阈值，就会产生买入信号。人们可以类似地调整 twsCALLBACK 的逻辑，根据自己的交易策略需求创建自定义回调。

twsCALLBACK custom callbacks

【IB 交易员工作站(TWS)

IB Trader Workstation T2】

结论

最后，这篇文章详细概述了 IBrokers 包的架构，它是交互式代理 API 的 R 实现。Interactive Brokers 与 QuantInsti 合作主办了一场名为“在 Interactive Brokers 上使用 R 进行交易”的网络研讨会，该研讨会于 2017 年 3 月 2 日举行，由 QuantInsti 总监 Anil Yadav 主持。您可以点击上面提供的链接来了解更多关于 IBrokers 包的信息。点击下面的下载按钮，获取网上研讨会中使用的相关 R 文件。

声明:

本软件不以任何方式隶属于 Interactive Brokers 或其任何附属机构，也没有得到其认可或批准。它没有任何保证，除非用户能够阅读并理解源代码，否则不应该在实际交易中使用。IBrokers 是 TWS API 的纯 R 实现。

下一步

如果你想学习算法交易的各个方面，那就去看看算法交易(EPAT)中的 T2 高管课程。该课程涵盖了统计学&计量经济学、金融计算&技术和算法&定量交易等培训模块。EPAT 让你具备成为成功交易者所需的技能。现在报名！

r .每周简报第一卷

原文：https://blog.quantinsti.com/r-weekly-bulletin-vol-i/

R Coding

我们从 R 每周公告开始，它将包含一些有趣的用 R 写代码和解决 bug 问题的方式和方法。我们还将为初学者介绍 R 函数和快捷键。我们知道用 R 编写代码的方法不止一种，公告中列出的解决方案可能不是您唯一的参考点。尽管如此，我们相信列出的解决方案将对我们的许多读者有所帮助。希望你喜欢我们的每周简报。享受阅读它们吧！

快捷键

  1. 将光标移动到 R 源代码编辑器- Ctrl+1
  2. 将光标移动到 R 控制台- Ctrl+2
  3. 要清除 R 控制台- Ctrl+L

解题思路

创建用户输入功能

为了在 R 中创建用户输入功能，我们可以使用 readline 函数。这给了我们在代码运行时为我们选择的变量设置输入值的灵活性。

例如:假设我们已经编写了一个回溯测试策略。我们希望有选择回溯测试周期的灵活性。为此，我们可以创建一个用户输入“n”，表示以年为单位的回溯测试期，并在代码的开头添加如下所示的行。

当代码运行时，它将提示用户输入“n”的值。输入值后，R 代码将在设定的时间内执行，并产生所需的输出。

n = readline(prompt = "Enter the backtest period in years: ")

每 x 秒刷新一次代码

为了每 x 秒刷新一次代码，我们可以使用 while 循环和 Sys.sleep 函数。“while 循环”一直执行封闭的命令块，直到条件保持满足。我们将代码放在 while 语句中，并保持条件为真。通过保持条件为真，它将继续循环。在代码的最后，我们添加了 Sys.sleep 函数，并以秒为单位指定延迟时间。这样，代码将每隔“x”秒刷新一次。

例子:在这个例子中，我们将 x 值初始化为零。代码每 1 秒刷新一次，它会一直打印 x 的值，你可以按键盘上的 escape 键终止代码。

x = 0 
while (TRUE) { 
x = x + 1 print(x) 
Sys.sleep(1) 
}

顺序运行多个 R 脚本

要运行多个 R 脚本，可以有一个包含要运行的脚本名称的主脚本。运行主脚本将导致其他 R 脚本的执行。假设主脚本的名称是“NSE 股票”。r”。在这个脚本中，我们将提到我们希望在源函数中运行的脚本的名称。在本例中，我们希望运行“顶级收益者”。r”和“最大输家”。r”脚本。这些将是“NSE 股票”的一部分。r "如下所示，我们运行主脚本来运行这两个脚本。

source("Top gainers.R")
source("Top losers.R")

将 R 脚本名包含在“source”函数中会导致 R 接受来自指定文件的输入。从该文件中读取并解析输入，直到到达文件的末尾，然后在所选的环境中按顺序计算解析后的表达式。或者，也可以将 R 脚本名放在一个向量中，并使用 sapply 函数。

举例:

filenames = c("Top gainers.R", "Top losers.R") 
sapply(filenames, source)

将美国格式的日期转换为标准日期格式

美国的日期格式是 mm/dd/yyyy 类型，而 ISO 8601 的标准格式是 yyyy-mm-dd。要将日期从美国格式转换为标准日期格式，我们将使用 as。日期函数和格式函数。下面的示例说明了该方法。

举例:

# date in American format dt = "07/24/2016" # If we call the as.Date function on the date, it will  
# throw up an error, as the default format assumed by the as.Date function is yyyy-mmm-dd.
as.Date(dt)

char tote(x)中的错误:字符串不是标准的明确格式

# Correct way of formatting the date 
as.Date(dt, format = "%m/%d/%Y")

[1] "2016-07-24"

如何从文件夹中删除所有现有文件

要从特定文件夹中删除所有文件，可以使用取消链接功能。指定文件夹的路径作为函数的参数。带有星号的正斜杠被添加到路径的末尾。下面给出了语法。

unlink(" path/*)

举例:

unlink("C:/Users/Documents/NSE Stocks/*")

这将删除“NSE 股票”文件夹中的所有文件。

功能去神秘化

write.csv 函数

如果您想在 csv 文件中保存数据帧或矩阵，R 提供了 write.csv 函数。write.csv 函数的语法如下所示:

write.csv(x，file="filename "，row.names=FALSE)

如果我们指定 row.names=TRUE，该函数将为每一行添加一个取自数据的 row.names 属性的标签。如果您的数据没有行名，那么函数只使用行号。默认情况下，写入列标题行。如果不需要列标题，请设置 col.names=FALSE。

举例:

# Create a data frame 
Ticker = c("PNB","CANBK","KTKBANK","IOB") 
Percent_Change = c(2.30,-0.25,0.50,1.24) 
df = data.frame(Ticker,Percent_Change) 
write.csv(df, file="Banking Stocks.csv", row.names=FALSE)

这将把“df”数据帧中包含的数据写入“Banking Stocks.csv”文件。文件保存在 R 工作目录中。

修复功能

fix 函数显示作为参数提供的函数的底层代码。

举例:

fix(sd)

标准差函数的底层代码如下所示。当我们使用“sd”作为参数执行 fix 函数时，就会显示这个消息。

function (x, na.rm = FALSE) 
sqrt(var(if (is.vector(x) || is.factor(x)) x else as.double(x), na.rm = na.rm))

download.file 功能

download.file 函数帮助从网站下载文件。这可以是网页、csv 文件、R 文件等。该函数的语法如下所示:

download.file( url ， destfile )

其中，url -要下载的文件的统一资源定位符(URL)destfile-保存下载文件的位置，即带有文件名的路径

示例:在本例中，该函数将从“url”参数中给定的路径下载文件，并以“betawacc.xls”的名称将其保存在 D 驱动器的“Skills”文件夹中。

url = "http://www.exinfm.com/excel%20files/betawacc.xls"
destfile = "D:/Skills/wacc.xls"
download.file(url, destfile)

下一步

我们希望你喜欢这个公告。在接下来的每周公告中，我们将为读者列出更多有趣的方式和方法以及 R 函数。

r 每周简报第二卷

原文：https://blog.quantinsti.com/r-weekly-bulletin-vol-ii/

本周的 R 公告将涵盖函数调用、数据帧排序、创建时序对象，以及 is.na、na.omit、paste、help、rep 和 seq 函数等函数。希望你喜欢这个 R 周刊。享受阅读！

快捷键

  1. 显示文件- Ctrl+5
  2. 显示绘图- Ctrl+6
  3. 要显示包- Ctrl+7

解题思路

在 R 脚本中调用函数

如果您想从另一个脚本调用您的 R 脚本中的自定义函数，可以使用“exists”函数和“source”函数。请参见下面的示例:

举例:

if(exists("daily_price_data", mode="function")) source("Stock price data.R")

在这种情况下，表达式将检查“股票价格数据”中是否存在名为“每日价格数据”的函数。r”脚本，如果是这样，它将在当前脚本中加载该函数。然后，通过提供相关参数，我们可以在脚本中多次使用该函数。

将日期从 Google finance 转换为时间序列对象

当我们从 Google finance 下载股票价格数据时,“DATE”列显示 yymmdd 格式的日期。这种格式在 r 中不被视为时间序列对象，要将 Google Finance 中的日期转换为时间序列对象，可以使用 lubridate 包中的 ymd 函数。ymd 函数接受年、月、日形式的日期。对于其他格式的日期，lubridate 包具有类似 ydm、mdy、myd、dmy 和 dym 的函数，这些函数可用于将其转换为时间序列对象。

举例:

library(lubridate)
dt = ymd(20160523)
print(dt)

[1] "2016-05-23"

按升序或降序对数据帧进行排序

dplyr 包中的排列函数可用于对数据框进行排序。第一个参数是 data.frame，下一个参数是排序所依据的变量，可以是升序，也可以是降序。

在下面的例子中，我们创建了一个两列数据框，由股票符号及其各自的价格变化百分比组成。然后，我们首先按升序对百分比变化列进行排序，然后再按降序对百分比变化列进行排序。

举例:

library(dplyr)
# Create a dataframe
Ticker = c("UNITECH", "RCOM", "VEDL", "CANBK")
Percent_Change = c(2.3, -0.25, 0.5, 1.24)
df = data.frame(Ticker, Percent_Change)
print(df)

股票价格百分比变化 1 尤尼泰 2.30 2 RCOM 0.25 3 韦德 1.50 4 加拿大元 1.24

# Sort in an ascending order
df_descending = arrange(df, Percent_Change)
print(df_descending)

1 RCOM -0.25 德国马克-0.50 德国马克-1.24 德国马克-2.30 德国马克

# Sort in a descending order
df_descending = arrange(df, desc(Percent_Change))
print(df_descending)

股票价格百分比变化 1 欧元兑换 1 美元 2.30 加元 1.24 美元 3 欧元兑换 1.50 美元 4 RCOM 0.25 美元

功能去神秘化

粘贴功能

粘贴是 R 中一个非常有用的函数，用于连接提供给它的参数。若要包含或删除参数之间的空格，请使用“sep”参数。

示例 1: 使用粘贴将一串单词和一个函数组合起来

x = c(20:45)
paste("Mean of x is", mean(x), sep = " ")

[1]“x 的平均值是 32.5”

示例 2: 使用目录路径、符号和文件扩展名作为粘贴函数的参数来创建文件名。

dirPath = "C:/Users/MyFolder/"
symbol = "INFY"
filename = paste(dirPath, symbol, ".csv", sep = "")
print(filename)

[1] "C:/Users/MyFolder/INFY.csv "

is.na 和 na.omit 函数

is.na 函数检查给定数据集中是否有 na 值，而 na.omit 函数将从给定数据集中删除所有 NA 值。

示例:考虑一个数据框架，该数据框架包括对应于每个日期的股票的开盘价和收盘价。

date = c(20160501, 20160502, 20160503, 20160504)
open = c(234, NA, 236.85, 237.45)
close = c(236, 237, NA, 238)
df = data.frame(date, open, close)
print(df)

日期开盘收盘 1 20160501 234.00 236 2 20160502 北美 237 3 20160503 236.85 北美 4 20160504 237.45 238

让我们使用 is.na 函数检查数据帧是否有 NA 值。

is.na(df)

日期打开关闭假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假假

从结果可以看出，它有两个 NA 值。现在让我们使用 na.omit 函数，并查看结果。

na.omit(df)

日期开盘收盘 1 2016 05 01 234.00 236 4 2016 05 04 237.45 238

从结果中可以看出，具有 NA 值的行被省略，并且结果数据帧现在仅包括非 NA 值。

这些函数可用于检查我们希望对其应用一些计算的大型数据集中的任何 NA 值。NA 值的存在会导致计算给出不需要的结果，因此这种 NA 值需要被移除或者被相关值代替。

重复和序列功能

rep 函数将参数重复指定的次数，而 sequence 函数用于形成所需的数字序列。请注意，在序列函数中，我们使用逗号，而不是冒号。

例 1:

rep("Strategy", times = 3)

[1]“策略”“策略”“策略”

rep(1:3, 2)

[1] 1 2 3 1 2 3

例 2:

seq(1, 5)

[1] 1 2 3 4 5

seq(1, 5, 0.5)

[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0

帮助和示例功能

help 函数提供关于主题排序的信息，而 example 函数提供关于给定主题的示例。

帮助(汇总)示例(汇总)

要访问与特定包中的特定函数相关联的 R 帮助文件，请将函数名作为 help 函数的第一个参数，同时包含第二个参数中提到的包名。

举例:

help(barplot, package="graphics")

或者，也可以键入一个问号，后跟函数名(例如？柱状图)并执行命令以了解关于该函数的更多信息。

下一步

我们希望你喜欢这个公告。在下一期每周简报中，我们将为读者列出更多有趣的方式方法加上 R 函数。

更新

我们注意到一些用户在从雅虎和谷歌金融平台下载市场数据时面临挑战。如果你正在寻找市场数据的替代来源，你可以使用 Quandl 来获得同样的信息。

r 每周简报第九卷

原文：https://blog.quantinsti.com/r-weekly-bulletin-vol-ix/

本周的 R 公告将涵盖如何使用 R 列出文件、提取文件名和创建文件夹的主题。希望你喜欢这个 R 每周公告。享受阅读！

快捷键

  1. 运行当前块- Ctrl+Alt+C
  2. 运行下一个块- Ctrl+Alt+N
  3. 运行当前函数定义- Ctrl+Alt+F

解决问题的想法

如何列出带有特定扩展名的文件

要列出具有特定扩展名的文件，可以使用 list.files 函数中的 pattern 参数。例如，要列出 csv 文件，请使用以下语法。

举例:

files = list.files(pattern = "\\.csv$")

这将列出当前工作目录中的所有 csv 文件。要列出任何其他文件夹中的文件，您需要提供文件夹路径。

 list.files(path = "C:/Users/MyFolder", pattern = "\\.csv$")

末尾的$表示这是字符串的结尾。添加中。确保只匹配带有扩展名的文件。战斗支援车

使用 gsub 函数提取文件名

当我们从 google finance 下载股票数据时，文件名与股票数据符号相对应。如果我们想从文件名中提取股票数据符号，我们可以使用 gsub 函数。该函数搜索模式参数的匹配项，并用替换参数中给出的替换值替换所有匹配项。该函数的语法如下所示:

 gsub(pattern, replacement, x)

在哪里，

pattern -是一个字符串，包含要在给定的字符向量中匹配的正则表达式。替换-匹配模式的替换。x -是寻找匹配的字符向量。

在下面给出的示例中，我们提取了存储在“Reading MFs”文件夹中的文件的文件名。我们已经在 R 工作目录中下载了两家公司的股票价格数据，即 MRF 公司和佩吉得公司

举例:

folderpath = paste(getwd(), "/Reading MFs", sep = "")
temp = list.files(folderpath, pattern = "*.csv")
print(temp)

[1] "MRF.csv" "PAGEIND.csv "

gsub("*.csv$", "", temp)

[1]" paging in "的 MRF

使用 R 创建一个文件夹

在“dir.create”函数的帮助下，可以通过 R 创建一个文件夹。该函数使用路径的最后一个元素中指定的名称创建一个文件夹。尾部路径分隔符被丢弃。

语法如下所示:

dir.create(path, showWarnings = FALSE, recursive = FALSE)

举例:

dir.create("D:/RCodes", showWarnings = FALSE, recursive = FALSE)

这将在 D 驱动器中创建一个名为“RCodes”的文件夹。

功能去神秘化

选择功能

select 函数来自 dplyr 包，可用于选择您需要的数据框的某些列。考虑示例中给出的数据帧“df”。

举例:

library(dplyr)
Ticker = c("INFY", "TCS", "HCL", "TECHM")
OpenPrice = c(2012, 2300, 900, 520)
ClosePrice = c(2021, 2294, 910, 524)
df = data.frame(Ticker, OpenPrice, ClosePrice)
print(df)


# Suppose we wanted to select the first 2 columns only. We can use the names of the columns in the 
# second argument to select them from the main data frame.

subset_df = select(df, Ticker:OpenPrice)
print(subset_df)


# Suppose we want to omit the OpenPrice column using the select function. We can do so by using
# the negative sign along with the column name as the second argument to the function.

subset_df = select(df, -OpenPrice)
print(subset_df)


# We can also use the 'starts_with' and the 'ends_with' arguments for selecting columns from the
# data frame. The example below will select all the columns which end with the word 'Price'.

subset_df = select(df, ends_with("Price"))
print(subset_df)

滤波函数

过滤器函数来自 dplyr 包，用于从数据框中提取行的子集。这个函数类似于 r 中的 subset 函数。

举例:

library(dplyr)
Ticker = c("INFY", "TCS", "HCL", "TECHM")
OpenPrice = c(2012, 2300, 900, 520)
ClosePrice = c(2021, 2294, 910, 524)
df = data.frame(Ticker, OpenPrice, ClosePrice)
print(df)


# Suppose we want to select stocks with closing prices above 750, we can do so using the filter 
# function in the following manner:

subset_df = filter(df, ClosePrice > 750)
print(subset_df)


# One can also use a combination of conditions as the second argument in filtering a data set.

subset_df = filter(df, ClosePrice > 750 & OpenPrice < 2000)
print(subset_df)

排列功能

arrange 函数是 dplyr 包的一部分，用于根据其中一列对数据框的行进行重新排序。通过使用特殊的 desc()运算符，可以按降序或升序排列列。

举例:

library(dplyr)
Ticker = c("INFY", "TCS", "HCL", "TECHM")
OpenPrice = c(2012, 2300, 900, 520)
ClosePrice = c(2021, 2294, 910, 524)
df = data.frame(Ticker, OpenPrice, ClosePrice)
print(df)


# Arrange in descending order

subset_df = arrange(df, desc(OpenPrice))
print(subset_df)


# Arrange in ascending order.

subset_df = arrange(df, -desc(OpenPrice))
print(subset_df)

下一步

我们希望你喜欢这个公告。在接下来的每周公告中，我们将为读者列出更多有趣的方式和方法以及 R 函数。

更新

我们注意到一些用户在从雅虎和谷歌金融平台下载市场数据时面临挑战。如果你正在寻找市场数据的替代来源，你可以使用 Quandl 来获得同样的信息。

r 每周简报第六卷

原文：https://blog.quantinsti.com/r-weekly-bulletin-vol-vi/

本周的 R 公告将涵盖诸如如何解析 R 中的毫秒、如何格式化日期以及提取日期和时间的特定部分的方法等主题。希望你喜欢这个 R 周刊。享受阅读！

快捷键

  1. 缩进-在行首点击 Tab 键
  2. 升级- Shift+Tab
  3. 转到特定行- Shift+Alt+G

解决问题的想法

如何在 R 中解析毫秒

当 R 从文本或电子表格文件中读取日期时，它通常会将它们存储为字符向量或因子。要将它们转换成日期，我们需要解析这些字符串。可以使用 strptime 函数完成解析，该函数返回 POSIXlt 日期。

要解析日期，必须告诉 strptime 字符串的哪些位对应于日期的哪些位。日期格式是使用字符串指定的，其组成部分用百分号后跟一个字母来指定。请参见下面的示例。这些组件与其他固定字符(如时间中的冒号或日期中的破折号和斜线)组合在一起，形成一个完整的规范。

举例:

strptime("25/06/2016 09:50:24", "%d/%m/%Y %H:%M:%S")

[1]“2016-06-25 09:50:24 IST”

如果一个字符串与格式字符串中的格式不匹配，则它取值 NA。例如，指定破折号而不是斜线会导致解析失败:

举例:

strptime("25-06-2016 09:50:24", "%d/%m/%Y %H:%M:%S")

[1]纳

为了解析 R 中的毫秒数，我们使用以下格式字符串:

举例:

strptime("25-06-2016 09:50:24.975", "%d-%m-%Y %H:%M:%OS")

[1]“2016-06-25 09:50:24.975 IST”op = options(digits . secs = 3)options(op)

options 函数允许用户设置和检查各种全局选项，这些选项会影响 R 计算和显示结果的方式。options 函数的参数“digits.secs”控制以秒为单位格式化时间值时要打印的最大位数。有效值为 0 到 6，默认值为 0。

如何设置日期格式

我们可以使用 strftime ("string format time ")函数按照我们的要求格式化日期。这个函数对 POSIXct 和 POSIXlt 日期类都有效，它将日期变量转换为字符串。

举例:

now_time = Sys.time()
# Let us first check the class of the the now_time variable by calling the
# class function.

class(now_time)

[1]" posi xct " " POSIX "

可以看出，它是一个“POSIXct”变量。为了正确格式化日期，我们需要使用正确的命名约定。例如，%B 表示月份的全名，%p 表示 AM/PM 时间指示器，依此类推。有关约定的完整列表，请查看函数的帮助页面。所需的格式约定放在引号中，并构成函数的第二个参数。strftime 函数用法的示例如下所示。

strftime(now_time, "%I:%M%p %A, %d %B %Y")

[1]“2017 年 4 月 29 日星期六上午 9:16”

提取日期和时间的特定部分

r 有两个标准的日期时间类，POSIXct 和 POSIXlt。POSIXct 类将日期存储为自 1970 年开始以来的秒数，而 POSIXlt 将日期存储为一个列表，其中包含秒、分钟、小时、一个月中的某一天等。可以使用列表索引来访问 POSIXlt 日期的各个部分。这些组件可以使用“松开”功能查看。

示例:在这个示例中，我们使用 Sys.time 函数，它给出当前的日期和时间。我们使用 as 将它转换成 POSIXlt 类。POSIXlt 函数。现在我们可以提取所需的组件。

time_now = as.POSIXlt(Sys.time())
print(time_now)

[1]“2017-04-29 09:16:06 IST”

unclass(time_now)

6.642435 美元

最低[1] 16 美元

$小时[1] 9

$mday [1] 29

$mon [1] 3

第[1]年 117 美元

$wday [1] 6

118 美元

$isdst [1] 0

$zone [1] "IST "

19800 美元

attr(，" tzo ")[1]"是""是"

# To extract minutes
time_now$min

[1] 16

# To extract day of the month
time_now$mday

[1] 29

功能去神秘化

%within%和%m+%函数

%它返回逻辑真或假作为输出。函数需要使用 interval 函数创建的日期时间间隔。我们使用 ymd 函数将非日期时间对象转换成日期时间对象。

举例:

library(lubridate)
dates = interval("2016-03-03", "2016-06-03")
d = ymd("2016-04-21")
d %within% dates

[1]正确

%m+%函数:该函数用于给定的日期时间对象加上或减去月份。

例子:

# To add a month to a date-time objects
library(lubridate)
d = ymd("2016-04-21")
d %m+% months(1)

[1] "2016-05-21"

# To create a sequence of months from a given date-time object
library(lubridate)
d = ymd("2016-04-21")
d %m+% months(1:3)

[1] "2016-05-21" "2016-06-21" "2016-07-21"

# To subtract a year from a given date-time object
d = ymd("2016-04-21")
d %m+% years(-1)

[1] "2015-04-21"

to.period 函数

to.period 函数是 xts 包的一部分。它将 OHLC 或单变量对象转换为低于给定数据对象的指定周期。

例如，函数可以将每日系列转换为每月系列，将每月系列转换为每年系列，将一分钟系列转换为每小时系列。

举例:

library(quantmod)
data = getSymbols("AAPL", src = "yahoo", from = "2016-01-01", to = "2016-01-15",
       auto.assign = FALSE)
nrow(data)

[1] 10

# Convert the above daily data series to weekly data.
to.period(data, period = "weeks")

有效的周期字符串包括:“秒”、“分”、“小时”、“天”、“周”、“月”、“季度”和“年”。

要将每日数据转换为每月数据，语法如下:

df = to.period(data，period = 'months')

结果将包含给定期间的开盘价和收盘价，以及新期间的最大值和最小值，分别反映在新高和新低中。如果某个时间段的体积可用，也将计算新的体积。

period.max 和 period.min 函数

period.max 和 period.min 函数是 xts 包的一部分。period.max 用于在给定要计算的部分的任意索引的情况下，计算每个周期的最大值。period.min 函数以类似的方式计算最小值。

语法如下所示:

period.max(x, index)
period.min(x, index)

其中，x -表示单变量数据对象索引-表示端点的数值向量

举例:

library(xts)
# compute the period maximum
period.max(c(1, 1, 4, 2, 2, 6, 7, 8, -1, 20), c(0, 3, 5, 8, 10))

3 5 8 10 4 2 8 20

# compute the period minimum
period.min(c(1, 1, 4, 2, 2, 6, 7, 8, -1, 20), c(0, 3, 5, 8, 10))

3 5 8 10 1 2 6 -1

下一步

我们希望你喜欢这个公告。在下一期每周简报中，我们将为读者列出更多有趣的方式方法加上 R 函数。

更新

我们注意到一些用户在从雅虎和谷歌金融平台下载市场数据时面临挑战。如果你正在寻找市场数据的替代来源，你可以使用 Quandl 来获得同样的信息。

r 每周简报第七卷

原文：https://blog.quantinsti.com/r-weekly-bulletin-vol-vii/

本周的 R bulletin 将涉及如何创建日期序列、如何给日期和时间变量添加数字以及如何将美国格式的日期转换为标准格式等主题。希望你喜欢这个 R 周刊。享受阅读！

快捷键

  1. 运行当前行/选择- Ctrl+Enter
  2. 将光标移动到行首- Home 键
  3. 将光标移动到行尾键的末尾

解决问题的想法

使用序列创建日期序列。日期功能

序列。日期函数可用于生成日期序列。该函数使用类“Date”处理日期。对于 POSIX 类的日期，可以使用 seq。POSIXt 函数同样适用。序列的语法。日期函数给定为:

序列。日期(从，到，到)

其中，“从”是开始日期。“到”是结束日期。这可以是一个可选参数。“by”是序列的增量。“length.out”采用整数值；这是一个可选参数，并指示序列的期望长度

例子:

# by month
seq(as.Date("2016/1/1"), by = "month", length.out = 12)

[1] "2016-01-01" "2016-02-01" "2016-03-01" "2016-04-01" "2016-05-01" [6] "2016-06-01" "2016-07-01" "2016-08-01" "2016-09-01" "2016-10-01" [11] "2016-11-01" "2016-12-01"

# by quarters.
seq(as.Date("2000/1/1"), as.Date("2003/1/1"), by = "quarter")

[1] "2000-01-01" "2000-04-01" "2000-07-01" "2000-10-01" "2001-01-01" [6] "2001-04-01" "2001-07-01" "2001-10-01" "2002-01-01" "2002-04-01" [11] "2002-07-01" "2002-10-01" "2003-01-01"

# If we specify a value in the 'by' argument, it will create a sequence of
# dates which are apart from that given value.
seq(as.Date("2000/1/1"), as.Date("2003/1/1"), by = "2 quarter")

[1] "2000-01-01" "2000-07-01" "2001-01-01" "2001-07-01" "2002-01-01" [6] "2002-07-01" "2003-01-01"

向日期和时间变量添加数字

R 中有三个日期和时间类:POSIXct、POSIXlt 和 date。当我们向 POSIXct 或 POSIXlt 类日期添加一个数字时，它会将给定数字的单位作为秒，因此它会将日期移动这些秒。

举例:

now_time = Sys.time()
print(now_time)

[1]“2017-05-06 21:01:19 IST”

# Let us add a value of 1 to the now_time date variable.
x = now_time + 1
print(x)

[1]“2017-05-06 21:01:20 IST”

从输出中可以看出，日期移动了 1 秒。如果我们想给“now time”变量加 1 天，我们必须给“now time”变量加 86400，因为 1 天相当于 86400 秒。这将使它提前一天。

now_time = Sys.time()
y = now_time + 86400
print(y)

[1]“2017-05-07 21:01:20 IST”

但是，如果日期存储为 date 类，则添加值 1 会将其向前移动 1 天。因此，以 date 类的形式向 Date 变量添加一个数字将使它移动那么多天。

now_time = as.Date(Sys.time())
print(now_time)

[1] "2017-05-06"

x = now_time + 1
print(x)

[1] "2017-05-07"

将美国日期格式转换为标准格式

美国的日期格式是 mm/dd/yyyy 类型，而 ISO 8601 的标准格式是 yyyy-mm-dd。为了将美国日期格式转换为标准格式，我们将使用 as。日期函数和格式函数。下面的示例说明了该方法。

举例:

# date in American format
dt = "07/24/2016"

# If we call the as.Date function on the date, it will throw up an error, as
# the default format assumed by the as.Date function is yyyy-mmm-dd.
as.Date(dt)

char tote(x)中的错误:字符串不是标准的明确格式

# Correct way of formatting the date
as.Date(dt, format = "%m/%d/%Y")

[1] "2016-07-24"

功能去神秘化

相同函数

恒等函数测试 R 中的两个对象是否完全相等。要比较的对象作为参数包含在函数中，函数返回逻辑真/假作为输出。

例子:

y1 = c(1:12)
y2 = c(1:12)
identical(y1, y2)

[1]正确

days = c("Mon", "Tues", "Wed", "Thurs", "Fri", "Sat", "Sun")
months = c("Jan", "Feb", "Mar", "April", "May", "June", "July")
identical(days, months)

[1]错误

全等函数

all.equal 函数用于检查数字是否相等。如果要比较的值不相同，all.equal 函数将返回差异报告。该函数的语法如下所示:

all.equal(目标，当前)

其中，目标是一个 R 对象。当前是其他 R 对象，与目标进行比较。

举例:

all.equal(3, 2)

[1]“平均相对差异:0.3333333”

# Using is.TRUE will return a logical value instead of the differences
# report.
isTRUE(all.equal(3, 2))

[1]错误

任何和所有功能

“any”函数用于检查给定的一组逻辑向量中是否有任何真值。“all”函数是另一个有用的函数，如果输入逻辑向量中的所有值都为真，则该函数返回真。

例 1:

sample = c(FALSE, FALSE, FALSE)
any(sample)

[1]错误

all(sample)

[1]错误

例 2:

sample = c(TRUE, FALSE, FALSE)
any(sample)

[1]正确

all(sample)

[1]错误

下一步

我们希望你喜欢这个公告。在接下来的每周公告中，我们将为读者列出更多有趣的方式和方法以及 R 函数。

r 每周简报第八卷

原文：https://blog.quantinsti.com/r-weekly-bulletin-vol-viii/

本周的 R bulletin 将涵盖绘制图表的主题，如保存图表、添加网格以及在单个图表中绘制多个数据集。希望你喜欢这个 R 周刊。享受阅读！

快捷键

  1. 运行当前文档- Ctrl+Alt+R
  2. 从文档开头运行到当前行- Ctrl+Alt+B
  3. 从当前行运行到文档结尾- Ctrl+Alt+E

解决问题的想法

将图保存到文件

r 允许您以不同的文件格式保存绘图，如 PNG、JPEG 或 PDF。以下示例概述了在 r 中保存图的过程。

示例:我们想为 BPCL 生成一个 2 年收盘价序列图，然后将该图保存到一个 PNG 文件中。我们首先调用 png 函数，并提供所需的文件名、绘图宽度和高度。然后，我们绘制价格序列以及绘图函数所需的参数。最后，我们使用 dev.off 函数关闭图形文件。文件保存在当前工作目录中，除非您指定了其他所需的路径。

library(quantmod)
bpcl = getSymbols("BPCL.NS", src = "yahoo", from = "2014-01-01", to = "2016-01-01",
                  auto.assign = FALSE)

bpcl_cl = Cl(bpcl)

plot.ts(bpcl_cl, main = "BPCL Price Series", xlab = "Days", ylab = "Close Price",
        type = "l", col = "red")


# Call the png function, Plot the vectors, and finally close the graphics file
png("Saving plot.png", width = 680, height = 480)
plot.ts(bpcl_cl, main = "BPCL Price Series", xlab = "Days", ylab = "Close Price",
        type = "l", col = "red")
dev.off()

pdf 2

# Saving the plot in pdf

pdf("Saving plot.pdf")
plot.ts(bpcl_cl, main = "BPCL Price Series", xlab = "Days", ylab = "Close Price",
        type = "l", col = "red")
dev.off()

pdf 2

向绘图添加网格

可以使用网格功能将网格添加到绘图中。为了绘制网格，我们首先使用 type="n "调用 plot 函数来初始化图形框架，而不显示数据。下一步，我们调用 grid 函数来绘制网格。最后，我们调用 lines 函数来绘制覆盖在网格上的图形。如果我们想要点而不是线，我们可以使用点函数。

举例:

library(quantmod)
techm = getSymbols("TECHM.NS", src = "yahoo", from = "2015-01-01", to = "2016-01-01",
                   auto.assign = FALSE)
techm_cl = coredata(Cl(techm))
days = index(Cl(techm))
# Adding grid to a line chart

plot(days, techm_cl, main = "TECHM Price Series", xlab = "Days", ylab = "Close Price", type = "n")
grid(col = "red", lwd = 1.5)
lines(days, techm_cl)


# Adding grid to a point chart

plot(days, techm_cl, main = "TECHM Price Series", xlab = "Days", ylab = "Close Price", type = "n")
grid(col = "blue", lwd = 1.5)
points(days, techm_cl)

绘制多个数据集

为了绘制多个数据集，我们使用 plot 这样的高级函数，然后使用 lines 这样的低级函数。由于多个数据集可能具有不同的 X 轴和 Y 轴范围，因此以这样一种方式设置两个轴的范围很重要，即绘图包含来自多个数据集的所有数据点。

在下面的例子中，我们绘制了两只股票的 1 年每日收盘价序列，即 PNB 和 CANBK。我们使用 range 函数来确定 xlim 和 ylim 参数。对两个数据集的收盘价序列调用 range 函数可以确保我们绘制出所有的数据点。此后，我们调用 PNB 股票收盘价序列的高级“绘图”函数，并定义其他必要的参数。然后，我们使用低级的“lines”函数来添加 CANBK 股票的收盘价序列。

举例:

library(quantmod)
pnb = getSymbols("PNB.NS", src = "yahoo", from = "2015-01-01", to = "2015-12-31",
                  auto.assign = FALSE)

canbk = getSymbols("CANBK.NS", src = "yahoo", from = "2015-01-01", to = "2015-12-31",
                    auto.assign = FALSE)

pnb_close = coredata(Cl(pnb))
canbk_close = coredata(Cl(canbk))
date = index(pnb)

main = "PNB-CANBK Daily Close Price Chart for 2015"
xlim = range(as.Date(date))
ylim = range(c(pnb_close, canbk_close))

plot(date, pnb_close, type = "l", lty = 1, pch = 19, col = "red", xlab = "Months",
     ylab = "Price", main = main, xlim = xlim, ylim = ylim)
# Add a line
lines(date, canbk_close, type = "l", lty = 1, pch = 18, col = "blue")

功能去神秘化

下载.文件

download.file 函数帮助从网站下载文件。这可以是网页、csv 文件、R 文件等。该函数的语法如下所示:

download.file( url ， destfile )

其中，url -要下载的文件的统一资源定位符(URL)destfile-保存下载文件的位置，即带有文件名的路径

示例:在这个示例中，该函数将从“url”参数中给定的路径下载文件，并以“betawacc.xls”的名称将其保存在 D 驱动器的“Skills”文件夹中。

url = "http://www.exinfm.com/excel%20files/betawacc.xls"
destfile = "D:/Skills/wacc.xls"
download.file(url, destfile)

文件.复制和文件.重命名

file.copy 函数将文件从一个文件夹复制到另一个文件夹，而 file.rename 函数重命名给定文件夹中的现有文件。

例子:函数中要复制的文件的路径作为第一个参数被提及，要复制的位置作为第二个参数被提及。

file.copy("C:/Users/MyFolder/TATACHEM.csv", "D:/Documents/TATACHEM.csv")

示例:函数中把要重命名的文件的路径作为第一个参数提及，把重命名后的文件的位置作为第二个参数提及。语法如下所示:

file.rename(from=(path of the file), to=(path of the file))

file.exists 和 file.remove

file.exists 函数用于检查一个特定的文件是否存在于设置的工作目录或其他指定为函数参数的文件夹中。file.remove 函数用于删除一个特定的文件，如果它存在于设定的工作目录中。

示例:这将检查“MyFolder”文件夹中是否存在“TATACHEM.csv”文件。

file.exists("C:/Users/MyFolder/TATACHEM.csv")
[1] TRUE

这将从“我的文件夹”文件夹中删除“TATACHEM.csv”文件。

file.remove("C:/Users/MyFolder/TATACHEM.csv")

下一步

我们希望你喜欢这个公告。在接下来的每周公告中，我们将为读者列出更多有趣的方式和方法以及 R 函数。

更新

我们注意到一些用户在从雅虎和谷歌金融平台下载市场数据时面临挑战。如果你正在寻找市场数据的替代来源，你可以使用 Quandl 来获得同样的信息。

r 每周简报第十卷

原文：https://blog.quantinsti.com/r-weekly-bulletin-vol-x/

本周的 R 公告将涵盖使用 ntile 函数对数据进行分组、如何自动打开文件以及使用 R 格式化 Excel 表格的主题。希望您喜欢这份 R 每周公告。享受阅读！

快捷键

  1. 折叠选定的块- Alt+L
  2. 展开选定的块- Shift+Alt+L
  3. 全部折叠- Alt+0

解决问题的想法

使用 ntile 函数对数据分组

ntile 函数是 dplyr 包的一部分，用于对数据进行分组。该函数的语法由下式给出:

ntile(x，n)

其中，“x”是值的向量,“n”是将数据分成的桶/组的数量。

举例:

在这个例子中，我们首先从两个向量创建一个数据帧，一个包含股票符号，另一个包含它们各自的价格。然后，我们将 Price 列中的值分成两组，等级被填充到名为“Ntile”的新列中。在最后一行中，我们使用 subset 函数只选择那些属于第二个存储桶的值。

library(dplyr)
Ticker = c("PAGEIND", "MRF", "BOSCHLTD", "EICHERMOT", "TIDEWATER")
Price = c(14742, 33922, 24450, 21800, 5519)

data = data.frame(Ticker, Price)

data$Ntile = ntile(data$Price, 2)
print(data)


ranked_data = subset(data, subset = (Ntile == 2))
print(ranked_data)

自动打开保存的文件

如果您正在保存执行 R 脚本时返回的输出，并且还想在运行代码后打开文件，您可以使用 shell.exec 函数。此函数使用 Windows 文件关联中指定的应用程序打开指定的文件。

文件关联将文件与能够打开该文件的应用程序相关联。更常见的是，文件关联关联一类文件(通常由文件扩展名决定，如。txt)和相应的应用程序(例如文本编辑器)。

下面的示例说明了函数的用法。shell.exec(文件名)

举例:

df = data.frame(Symbols=c("ABAN","BPCL","IOC"),Price=c(212,579,538))
write.csv(df,"Stocks List.csv")
shell.exec("Stocks List.csv")

excel 表格列宽的快速格式

我们可以使用下面给出的命令行格式化 excel 表格的列宽。在该示例中，第一行将加载由文件名指定的 excel 工作簿。在第三行和第四行，autoSizeColumn 函数为每个工作表调整列的宽度，这是在“colIndex”中指定的。最后一行将在进行必要的格式更改后再次保存工作簿。

举例:

wb = loadWorkbook(file_name)
sheets = getSheets(wb)
autoSizeColumn(sheets[[1]], colIndex=1:7)
autoSizeColumn(sheets[[2]], colIndex=1:5)
saveWorkbook(wb,file_name)

功能去神秘化

选择功能

choose 函数计算组合 nCr。该函数的语法如下所示:

选择(n，r)

其中，n 是元素的数量，r 是子集元素的数量

nCr = n！/(r！* (n-r)！)

例子:

choose(5, 2)

[1] 10

choose(2, 1)

[1] 2

样本函数

sample 函数从给定的向量中随机选择 n 个项目。样本的选择没有替换，这意味着该功能不会两次选择相同的项目。该函数的语法如下所示:

样本(向量，n)

举例:考虑一个由一只股票的年收入增长数据组成的向量。我们使用样本函数随机选择 5 年的收入增长。

Revenue = c(12, 10.5, 11, 9, 10.75, 11.25, 12.1, 10.5, 9.5, 11.45)
sample(Revenue, 5)

[1] 11.45 12.00 9.50 12.10 10.50

一些统计过程需要替换抽样，在这种情况下，您可以为 sample 函数指定 replace= TRUE。

举例:

x = c(1, 3, 5, 7)
sample(x, 7, replace = TRUE)

[1] 7 1 5 3 7 3 5

runif 和 rnorm 函数

runif 函数生成一个介于 0 和 1 之间的均匀随机数。runif 函数的自变量是要生成的随机值的个数。

举例:

# This will generate 7 uniform random number between 0 and 1.
runif(7)

[1] 0.6989614 0.5750565 0.6918520 0.3442109 0.5469400 0.7955652 0.5258890

# This will generate 5 uniform random number between 2 and 4.
runif(5, min = 2, max = 4)

[1] 2.899836 2.418774 2.906082 3.728974 2.720633

rnorm 函数根据正态分布生成随机数。函数 rnorm 代表正态分布的随机数生成器。该函数的语法如下所示:

rnorm(n，均值，标准差)

举例:

# generates 6 numbers from a normal distribution with a mean of 3 and standard deviation of 0.25
rnorm(6, 3, 0.25)

[1] 3.588193 3.095924 3.240684 3.061176 2.905392 2.891183

下一步

我们希望你喜欢这个公告。在下一期每周简报中，我们将为读者列出更多有趣的方式方法加上 R 函数。

r 每周简报第一卷——Xi

原文：https://blog.quantinsti.com/r-weekly-bulletin-vol-xi/

本周的 R 公告将涵盖如何舍入到最接近的所需数字、转换和比较日期以及如何从元素中删除最后 x 个字符的主题。希望你喜欢这个 R 周刊。享受阅读！

快捷键

  1. 注释/取消注释当前行/选择- Ctrl+Shift+C
  2. 向上/向下移动行-Alt+向上/向下
  3. 删除行- Ctrl+D

解决问题的想法

舍入到最接近的所需数字

考虑这样一种情况，您想要将一个给定的数字四舍五入到最接近的 25。这可以通过以下方式完成:

round(145/25) * 25

[1] 150

floor(145/25) * 25

[1] 125

ceiling(145/25) * 25

[1] 150

用法:假设您正在计算最小报价单位为 5 派息的 NSE 股票的止损或获利。在这种情况下，我们将除以并乘以 0.05，以获得所需的结果。

举例:

Price = 566
Stop_loss = 1/100
# without rounding
SL = Price * Stop_loss
print(SL)

[1] 5.66

# with rounding to the nearest 0.05
SL1 = floor((Price * Stop_loss)/0.05) * 0.05
print(SL1)

[1] 5.65

如何移除每个元素的最后 n 个字符

为了删除最后 n 个字符，我们将使用 substr 函数和 nchr 函数。下面的例子说明了做这件事的方法。

举例:

# In this case, we just want to retain the ticker name which is "TECHM"
symbol = "TECHM.EQ-NSE"
s = substr(symbol,1,nchar(symbol)-7)
print(s)

[1]“TECHM”

转换和比较不同格式的日期

当我们从 Google finance 中提取股票数据时，日期显示为“YYYYMMDD”，它不能被识别为日期-时间对象。要将其转换为日期时间对象，我们可以使用 lubridate 包中的“ymd”函数。

举例:

library(lubridate)
x = ymd(20160724)
print(x)

[1] "2016-07-24"

另一个数据提供程序提供股票数据，该数据具有美国格式(mm/dd/yyyy)的日期时间对象。当我们读取文件时，日期-时间列被作为字符读取。我们需要将它转换成一个日期时间对象。我们可以使用。日期函数，并通过指定格式。

dt = "07/24/2016"
y = as.Date(dt, format = "%m/%d/%Y")
print(y)

[1] "2016-07-24"

# Comparing the two date-time objects (from Google Finance and the data provider) after conversion
identical(x, y)

[1]正确

功能去神秘化

等级函数

rank 函数返回向量中值的样本等级。可以用几种方式处理平局(即相等的值)和缺失值。

rank(x， na 。last = TRUE，ties.method = c("average "，" first "，" random "，" max "，" min"))

其中， x: 数值、复数、字符或逻辑向量 na 。最后:用于控制 NAs 的治疗。如果为真，则数据中缺失的值被放在最后；如果为假，则放在第一位；如果 NA，它们被移除；如果“keep ”,它们将与秩 NA ties 一起保存。方法:指定如何处理 ties 的字符串

例子:

x <- c(3, 5, 1, -4, NA, Inf, 90, 43)
rank(x)

[1] 3 4 2 1 8 7 6 5

rank(x, na.last = FALSE)

[1] 4 5 3 2 1 8 7 6

变异和改变功能

变异和转化函数是 dplyr 包的一部分。mutate 函数使用给定数据框的现有变量计算新变量。新变量被添加到现有数据框中。另一方面，转化函数将这些新变量创建为单独的数据框。

考虑下例中给出的数据帧“df”。假设我们对一只股票的 1 分钟价格数据进行了 5 次观察，我们希望通过从 1 分钟收盘价中减去平均值来创建一个新变量。这可以通过使用 mutate 函数以下面的方式完成。

举例:

library(dplyr)
OpenPrice = c(520, 521.35, 521.45, 522.1, 522)
ClosePrice = c(521, 521.1, 522, 522.25, 522.4)
Volume = c(2000, 3500, 1750, 2050, 1300)
df = data.frame(OpenPrice, ClosePrice, Volume)
print(df)


df_new = mutate(df, cpmean_diff = ClosePrice - mean(ClosePrice, na.rm = TRUE))
print(df_new)


# If we want the new variable as a separate data frame, we can use the transmute function instead.
df_new = transmute(df, cpmean_diff = ClosePrice - mean(ClosePrice, na.rm = TRUE))
print(df_new)

set.seed 函数

set.seed 函数有助于在程序每次运行时生成相同的随机数序列。它将随机数发生器设置为已知状态。该函数接受一个整数参数。为了得到相同的初始状态，需要使用相同的正整数。

举例:

# Initialize the random number generator to a known state and generate five random numbers
set.seed(100)
runif(5)

[1] 0.30776611 0.25767250 0.55232243 0.05638315 0.46854928

# Reinitialize to the same known state and generate the same five 'random' numbers
set.seed(100)
runif(5)

[1] 0.30776611 0.25767250 0.55232243 0.05638315 0.46854928

下一步

我们希望你喜欢这个公告。在下一期每周简报中，我们将为读者列出更多有趣的方式方法加上 R 函数。

更新

我们注意到一些用户在从雅虎和谷歌金融平台下载市场数据时面临挑战。如果你正在寻找市场数据的替代来源，你可以使用 Quandl 来获得同样的信息。

r 每周简报第 12 卷

原文：https://blog.quantinsti.com/r-weekly-bulletin-vol-xii/

本周的 R 公告将涵盖如何解决 R 中一些常见错误的主题。希望您喜欢这份 R 每周公告。享受阅读！

快捷键

  1. 查找和替换- Ctrl+F
  2. 查找下一个- F3
  3. 查找上一个- Shift+F3

解决问题的想法

正在解析“无法打开连接”错误

当我们运行 R 脚本时，出现这个错误可能有两个原因:1)文件/连接无法打开，因为 R 找不到它(主要是由于路径错误)。onLoad()，因为包找不到系统依赖项

举例:

symbol = "AXISBANK"
noDays = 1
dirPath = paste(getwd(), "/", noDays, " Year Historical Data", sep = "")
fileName = paste(dirPath, symbol, ".csv", sep = "")
data = as.data.frame(read.csv(fileName))

文件中的警告(文件，“rt”):无法打开文件“C:/Users/Madhukar/Documents/ 1 年历史数据 AXISBANK.csv”:文件中没有这样的文件或目录错误(文件，“rt”):无法打开连接

我们得到这个错误是因为我们在代码中为“dirPath”对象指定了错误的路径。正确的路径如下所示。我们在粘贴函数中遗漏了在“年历史数据”后添加一个正斜杠。这导致了错误的道路，因此错误。

dirPath = paste(getwd()，"/"，noDays，"年历史数据/"，sep= " ")

添加正斜杠后，我们重新运行代码。下面我们可以看到在 R 控制台中打印的正确的目录路径和文件名。

举例:

symbol = "AXISBANK"
noDays = 1
dirPath = paste(getwd(), "/", noDays, " Year Historical Data/", sep = "")
fileName = paste(dirPath, symbol, ".csv", sep = "")
data = as.data.frame(read.csv(fileName))
print(head(data, 3))

解决“找不到函数”错误

当一个 R 包没有被正确加载或者由于函数名的拼写错误，这个错误就会出现。

当我们运行下面显示的代码时，我们在控制台中得到一个“找不到 ymd 函数”错误。这是因为我们把“ymd”函数拼错成了“ymed”。如果我们不加载所需的包，这也会抛出一个“找不到函数 ymd”的错误。

举例:

# Read NIFTY price data from the csv file
df = read.csv("NIFTY.csv")
# Format date
dates = ymed(df$DATE)

eval(expr，envir，enclos)出错:找不到函数“ymed”

解决“替换有”错误

当试图将值的向量分配给现有对象并且长度不匹配时，会发生此错误。

在下面的示例中，安讯士银行的股票价格数据有 245 行。在代码中，我们创建了从 1 到 150 的数字序列“s”。当我们试图将这个序列添加到 Axis Bank 数据集时，它会抛出一个“替换错误”,因为两者的长度不匹配。因此，为了解决这种错误，应该确保长度匹配。

举例:

symbol = "AXISBANK" ; noDays = 1 ;
dirPath = paste(getwd(),"/",noDays," Year Historical Data/",sep="")
fileName = paste(dirPath,symbol,".csv",sep="")
df = as.data.frame(read.csv(fileName))
# Number of rows in the dataframe "df"
n = nrow(df); print(n);
# create a sequence of numbers from 1 to 150
s = seq(1,150,1)
# Add a new column "X" to the existing data frame "df"
df$X = s
print(head(df,3))

＄tmp，" X "中的错误，value = c(1，2，3，4，5，6，7，:替换有 150 行，数据有 245 行

功能去神秘化

通话功能

do.call 函数用于调用其他函数。要调用的函数作为 do.call 函数的第一个参数提供，而 do.call 函数的第二个参数是要调用的函数的参数列表。该函数的语法如下所示:

do.call(函数名，参数)

示例:让我们首先定义一个简单的函数，稍后我们将在 do.call 函数中调用它。

numbers = function(x, y) {
sqrt(x^3 + y^3)
}
# Now let us call this 'numbers' function using the do.call function. We provide the function name as # the first argument to the do.call function, and a list of the arguments as the second argument.

do.call(numbers, list(x = 3, y = 2))

[1] 5.91608

重命名功能

rename 函数是 dplyr 包的一部分，用于重命名数据框的列。rename 函数的语法是将新名称放在=符号的左边，旧名称放在右边。考虑下例中给出的数据帧“df”。

举例:

library(dplyr)
Tic = c("IOC", "BPCL", "HINDPETRO", "ABAN")
OP = c(555, 570, 1242, 210)
CP = c(558, 579, 1248, 213)
df = data.frame(Tic, OP, CP)
print(df)


# Renaming the columns as 'Ticker', 'OpenPrice', and 'ClosePrice'. This can be done in the following 
# manner:

renamed_df = rename(df, Ticker = Tic, OpenPrice = OP, ClosePrice = CP)
print(renamed_df)

重叠函数

lapply 函数是 R 基础包的一部分，它将一个列表“x”作为输入，并返回一个与“x”长度相同的列表，其中的每个元素都是对 x 的相应元素应用函数的结果。该函数的语法如下所示:

lapply(x，Fun)其中，x 是一个向量(原子或列表), Fun 是要应用的函数

例 1:

让我们创建一个包含两个元素的列表，OpenPrice 和 ClosePrice。我们将使用 lapply 函数计算每个元素中值的平均值。

x = list(OpenPrice = c(520, 521.35, 521.45), ClosePrice = c(521, 521.1, 522))
lapply(x, mean)

OpenPrice [1] 520.9333 美元

close store[1]521 3667 美元

例 2:

x = list(a = 1:10, b = 11:15, c = 1:50)
lapply(x, FUN = length)

十美元

5 美元

50 美元

下一步

我们希望你喜欢这个公告。在下一期每周简报中，我们将为读者列出更多有趣的方式方法加上 R 函数。

r 每周简报第十三卷

原文：https://blog.quantinsti.com/r-weekly-bulletin-vol-xiii/

本周的 R bulletin 涵盖了一些有趣的绘图方法。希望你喜欢这个 R 周刊。享受阅读！

快捷键

  1. 源文件- Ctrl+Shift+O
  2. 获取当前文档- Ctrl+Shift+S
  3. 在文件中查找- Ctrl+Shift+F

解决问题的想法

使用多种颜色绘制变量

用多种颜色绘制一个变量可以很容易地辨别出绘制数据中的模式，并且可以使用“col”参数来完成。plot 函数的其余参数基本保持不变。让我们考虑一个例子来说明多色绘图。

例子:在这里，我们正在为在 MRF 上市的 NSE 股票寻找一年的数据。使用 quantmod 包中的 dailyReturn 函数，我们根据股票的每日收盘价计算每日回报率。

我们打算用深绿色绘制正收益，用红色绘制负收益。为此，我们使用 ifelse 语句创建一个名为“colors”的向量，如下所示。ifelse 语句作用于一个向量，我们称之为“returns”向量。

这个“颜色”向量用作绘图函数中“颜色”参数的值。绘图函数中的“类型”参数必须保持为“h”。绘图函数中使用的其余参数不言自明。

library(quantmod)
mrf = getSymbols("MRF.NS", src="yahoo", from="2017-01-01", to="2017-06-01", auto.assign=FALSE)
returns = dailyReturn(Cl(mrf))*100
date = index(mrf)
colors = ifelse(returns >= 0, "darkgreen", "red")
plot(date,returns, type="h",lwd=2, col=colors, xlab="Period", ylab="Daily returns(%)", main="MRF Daily Returns for 1H-2017")

在单页上显示多个绘图

为了在一个页面上显示多个图形，我们使用 par(mfrow)函数将图形窗口分成一个矩阵。我们在 par 函数的 mfrow 参数中指定行数和列数。比如 m flow = c(2，2)会把空间分成四个部分。

然后，我们调用高级函数来绘制数据集。如果我们想要绘制四个数据集并分别显示它们，我们将使用高级函数调用它们四次。下面给出的例子说明了这一点。

举例:

library(quantmod)
ktkbank=getSymbols("KTKBANK.NS", src="yahoo", from="2016-01-01", to="2016-12-31",auto.assign=FALSE)
unionbank=getSymbols("UNIONBANK.NS",src="yahoo",from="2016-01-01",to="2016-12-31",auto.assign=FALSE)

ktkbank_close = coredata(Cl(ktkbank))
unionbank_close = coredata(Cl(unionbank))
date = index(ktkbank)

par(mfrow = c(1, 2))
plot(date, ktkbank_close, type = "l", lty = 1, pch = 19, col = "red", xlab = "Period",
ylab = "Price", main = "KTKBANK")
plot(date, unionbank_close, type = "l", lty = 1, pch = 19, col = "blue", xlab = "Period",ylab = "Price", main = "UNIONBANK")

更改打印的全局参数

许多函数都有多个参数。对于其中的一些参数，R 已经设置了默认值。这些默认值有助于节省时间，因为我们不必为函数的每个参数都设置一个值。

如果我们不想使用默认值并为函数的任何特定参数设置自己的值，可以使用 par 函数来实现。可以通过使用参数名调用 par 函数来检查参数的当前默认值。

举例:

par("col")

[1]“黑色

为了设置自己选择的新值，我们可以通过调用 par 函数来设置新值，并将新值赋给参数。

举例:

par(col="blue")

有一长串这样的参数，它们的默认值可以使用 par 函数来更改。请参考 par 函数的帮助页面，其中列出了这些参数。请注意，当您更改全局参数的默认值时，它将影响所有的图，而不仅仅是当前的图。要重置原始值，请在完成绘图后为参数指定原始值。下面的例子说明了同样的情况:

library(quantmod)
# make a copy of current settings
original_value = par("lty")
print(original_value)

[1]“固体”

# set the global parameter using the par function
par(lty ="dashed")
# create a plot with the new setting
idbi=getSymbols("IDBI.NS", src="yahoo", from="2016-01-01", to="2016-12-01",auto.assign=FALSE)
high = coredata(Hi(idbi))
low = coredata(Lo(idbi))
date = index(idbi)
main = "IDBI Daily Price Chart for 2016"
plot(date, high, type = "l", pch = 19, col = "red", xlab = "Date", ylab = "Price", main = main)


# Restore the global parameter to its default value
par(lty = original_value)

功能去神秘化

sapply 和 vapply 函数

sapply 函数是 lapply 的用户友好版本和包装器，它接受一个列表作为输入并返回一个向量。如果“simplify”参数作为“array”输入，则 sapply 函数将返回一个数组。

sapply(x, f, simplify = FALSE, USE.NAMES = FALSE) is the same as lapply(x, f)

举例:

x = list(a = 1:10, b = 11:15, c = 1:50)
sapply(x, FUN = length)

甲乙丙丁十五五十

vapply 函数类似于 sapply，但是有一个预先指定的返回值类型，所以使用起来更安全，有时更快。

举例:

# We are specifying the return value to be an integer using the FUN.VALUE argument
x = list(a = 1:10, b = 11:15, c = 1:50)
vapply(x, FUN = length, FUN.VALUE = 0L)

甲乙丙丁十五五十

group_by 函数

该函数是 dplyr 包的一部分，用于给定数据集分组。人们可以对这样的分组数据执行不同的操作。该函数的语法如下所示:

group_by(data, variables, add = FALSE)

其中，data -是给定的数据集变量-作为分组依据的变量的名称。add -默认情况下，当 add = FALSE 时，group_by 将覆盖现有组。要添加到现有组中，请使用 add = TRUE

示例:在这个示例中，NIFTY 文件包含 3 天 1 分钟的当天数据。IST 证交所交易时段从上午 9:15 开始，下午 3:30 结束。我们使用“Time”变量调用 group_by 函数，然后计算数据文件中提到的每个时间段(分钟)的观察次数。为此，我们对分组数据调用 summarise 函数，并使用 n()函数计算每个时间段的观察次数。从输出中可以看出，从 916 到 1530，每个时间段有 3 个观测值。

library(dplyr)
df = read.csv("NIFTY_3days_intraday.csv")
colnames(df) = c("Date", "Time", "Close", "High", "Low", "Open", "Volume")
dt = group_by(df, Time)
sm = summarise(dt, n = n())
print(sm)

rollMean rollMin 和 rollMax 函数

这些函数是 timeSeries 包的一部分。它们计算时间序列对象的滚动平均值、最小值和最大值。滚动平均值的语法如下所示:

rollMean(x, k, na.pad = FALSE)

其中，x 是单变量或多变量“时间序列”对象。k 是滚动窗口的整数宽度。na.pad 是用于填充的逻辑标志。默认情况下，它是假的。

举例:

library(timeSeries); library(quantmod);
data = getSymbols("SBIN.NS", src="yahoo", from="2017-01-01", to="2017-01-15", auto.assign=FALSE)
open = timeSeries(data$SBIN.NS.Open)
print(head(open, 5))


rollMean(open, k = 4, na.pad = FALSE)

其他两个函数的工作方式与 rollMean 相似。

举例:

library(timeSeries); library(quantmod);
data = getSymbols("IOC.NS", src="yahoo", from="2017-01-01", to="2017-01-15", auto.assign=FALSE)
close = timeSeries(data$IOC.NS.Close)
rollMax(close, k = 5, na.pad = FALSE)

下一步

我们希望你喜欢这个公告。在下一期每周简报中，我们将为读者列出更多有趣的方式方法加上 R 函数。

更新

我们注意到一些用户在从雅虎和谷歌金融平台下载市场数据时面临挑战。如果你正在寻找市场数据的替代来源，你可以使用 Quandl 来获得同样的信息。

r 每周简报第 14 卷

原文：https://blog.quantinsti.com/r-weekly-bulletin-vol-xiv/

本周的 R 公告涵盖了一些列出函数、列出文件的有趣方法，并举例说明了双冒号操作符的使用。希望你喜欢这个 R 周刊。享受阅读！

快捷键

  1. 新建文档- Ctrl+Shift+N
  2. 关闭活动文档- Ctrl+W
  3. 关闭所有打开的文档- Ctrl+Shift+W

解决问题的想法

如何列出 R 包中的函数

我们可以通过使用“jwutil”s 包来查看特定 R 包中的函数。安装软件包并使用软件包中的 lsf 函数。该函数的语法如下所示:

lsf(包装)

其中 pkg 是包含包名的字符串。

该函数返回给定包中函数名的字符向量。

举例:

library(jwutil)
library(rowr)
lsf("rowr")

如何列出带有特定扩展名的文件

要列出具有特定扩展名的文件，可以使用 list.files 函数中的 pattern 参数。例如，要列出 CSV 文件，请使用以下语法:

举例:

# This will list all the csv files present in the current working directory.
# To list files in any other folder, you need to provide the folder path.

files = list.files(pattern = "\\.csv$")
# $ at the end means that this is end of the string.
# Adding \. ensures that you match only files with extension .csv

list.files(path = "C:/Users/MyFolder", pattern = "\\.csv$")

使用双冒号运算符

双冒号运算符用于访问命名空间中导出的变量。语法如下所示:

pkg::名称

其中 pkg 是包名符号或文字字符串。name 参数是变量名符号或文字字符串。

如果有名称空间，表达式 pkg::name 将返回从包中导出的变量的值。如果该包在调用之前尚未加载，则它将被加载。当我们有来自不同包的同名函数时，使用双冒号操作符是有好处的。在这种情况下，库的加载顺序很重要。

要查看这些冒号操作符的帮助文档，您可以在 R -？::'或帮助("::😊

举例:

library("dplyr")

first = c(1:6)
second = c(3:9)

dplyr::intersect(first, second)
[1] 3 4 5 6
base::intersect(first, second)
[1] 3 4 5 6

在这个例子中，我们有两个同名的函数，但是来自不同的 R 包。在某些情况下，同名函数会产生不同的结果。通过使用双冒号操作符指定各自的包名，R 知道在哪个包中查找该函数。

功能去神秘化

path.package 函数

path.package 函数返回找到给定包的位置的路径。如果没有提到这个包，那么这个函数将返回所有当前附加包的路径。该函数的语法如下所示:

path.package(包，安静=假)

quiet 参数采用默认值 False。如果将此参数更改为 True，那么如果参数中指定的包没有附加，它将抛出警告；如果没有附加，它将给出错误。

举例:

path.package("stats")

fill.na 函数

有不同的 R 包具有填充 NA 值的功能。fill.na 函数是 mefa 包的一部分，它将 na 值替换为同一列中它们上面最近的值。该函数的语法如下所示:

fill.na(x)

其中，x 可以是向量、矩阵或数据帧。

举例:

library(mefa)
x = c(12,NA,15,17,21,NA)
fill.na(x)

等级函数

rank 函数返回向量中值的样本等级。可以用几种方式处理平局(即相等的值)和缺失值。

rank(x，na.last = TRUE，ties.method = c("平均"，"第一"，"随机"，"最大"，"最小"))

其中，x:数字、复数、字符或逻辑向量 na.last:用于控制 NAs 的处理。如果为真，则数据中缺失的值被放在最后；如果为假，则放在第一位；如果 NA，它们被移除；如果“keep ”,则它们与秩 NA ties 一起保存。方法:指定如何处理 ties 的字符串

例子:

x = c(3, 5, 1, -4, NA, Inf, 90, 43)
rank(x)


rank(x, na.last = FALSE)

下一步

使用 RExcel 在 Excel 中实现 R 函数的分步教程。了解如何使用 RExcel 在 R 和 Excel 之间无缝传输数据。点击这里立即阅读。

交易中的云计算:类型、模型、自动化及更多

原文：https://blog.quantinsti.com/raining-data-cloud-computing-solutions-for-retail-traders/

由查尼卡·塔卡

云计算是大多数企业不可或缺的一部分。由于云计算提供的便利、安全和可靠的服务，它在交易领域得到了广泛的应用。尤其是因为用户可以在任何地方工作。

在当今这个数据无处不在的当代世界，云计算被证明是零售交易商、机构和几乎所有金融市场参与者的福音。

本文涵盖:

什么是云计算？

云计算是通过互联网(“云”)交付计算服务，包括服务器、存储、数据库、网络、软件、分析和智能。

云计算是一项服务，旨在让任何人和每个使用互联网的人都可以访问。这是一个开放的平台，人们需要通过互联网连接登陆，而不需要任何硬件或软件。

各种类型、规模和业务类型的不同公司和行业正在出于各种原因使用云，例如数据备份、灾难恢复、虚拟桌面需求、软件开发、大数据分析等。

例如，医院正在利用云为病人开发更个性化的治疗。同样，金融服务公司正在使用云来支持实时欺诈检测和防范。

此外，预计云计算市场规模将很快在 2022 年达到 4052.958 亿美元，并在 2028 年达到 14658.182 亿美元。

Cloud storage market

Cloud storage market

由于云计算提供了更快的创新和灵活的资源，因此非常方便。此外，像 Blueshift 这样的云计算平台是免费的，这也有助于您确保低成本。

随着时间的推移，金融领域的云计算正迅速获得广泛的吸引力。

云计算的历史

云计算的历史和发展可以追溯到 20 世纪 50 年代和 60 年代。20 世纪 50 年代，公司开始使用大型主机。但是由于为每个用户购买一台电脑太贵了，在 20 世纪 50 年代末和 60 年代初，一种叫做分时的方法被开发出来。

分时意味着将多台计算机连接到主机上的设备。与其他计算机相比，大型机具有更大的内存和更强的处理能力。

因此，将大型机与其他计算机连接起来，就可以与那些连接的计算机共享大型机的内存和处理能力。

通过将大型计算机与其他多台计算机连接起来，分时有助于更有效地利用大型计算机上昂贵的处理器时间。

20 世纪 70 年代，随着第一台虚拟机的推出，云计算开始变得更加有形，使用户能够在一个物理环境中运行多个计算系统。

这些虚拟机的功能导致了虚拟化的概念，这对云计算的发展产生了重大影响。

谷歌在 2021 年的一项调查中发现:

  • 93%的交易所、交易系统和数据提供商提供基于云的数据和服务。
  • 67%的商业和投资银行使用云部署的市场数据。
  • 90%接受调查的买方公司使用云部署的市场数据，主要用于投资组合管理。

在他们的文章中，网络安全风险投资公司预测，到 2025 年，云上的全球数据存储将扩大到 100 吉字节——一吉字节等于十亿兆兆字节(或一万亿吉字节)。

云服务的类型

云计算服务有三种不同的模式，即 Saas、PaaS 和 IaaS。虽然这三者通常被描述为堆叠的层，但是每个提供商甚至可以提供其中的任何一个。

例如，提供商可以提供交易功能的 SaaS 实现，而无需使用底层的 PaaS 或 IaaS 层。类似地，人们可以在 IaaS 上运行程序并直接访问它，而不需要 SaaS。

让我们进一步了解每个型号。

Cloud deployment models

Cloud deployment models - Source: Wikipedia

软件即服务(SaaS)

用户可以在软件即服务(SaaS)模式中访问应用软件和数据库。云提供商管理运行应用程序的基础设施和平台。在 SaaS 模式中，云提供商在云中安装和运行应用软件，云用户通过提供商访问软件。

平台即服务(PaaS)

在 PaaS 中，云提供商提供一个平台，通常包括操作系统、编程语言执行环境、数据库和 web 服务器。应用程序开发人员在云平台上开发和运行他们的软件，而不是直接购买和管理底层硬件和软件层。

基础设施即服务(IaaS)

基础设施即服务或 IaaS 是指提供高级 API 的在线服务，这些 API 用于抽象底层网络基础设施的各种低级细节，如物理计算资源、位置、数据分区、扩展、安全性、备份等。

云计算部署模型的类型

云计算模型有三种类型。让我们简单看看这三种类型是什么:

私有云

私有云是一种云计算模式，在这种模式下，企业使用专有架构，并在自己的数据中心内运行云服务器。

混合云

混合云是一种云计算模式，包括内部、私有云及第三方公共云服务的混合，并在两个平台之间进行协调。

公共云

公共云是一种云计算模式，其中第三方提供商通过互联网向公众提供计算资源。有了公共云，企业不必在内部设置和维护自己的云服务器。

Cloud computing deployment models

Cloud computing deployment models

基于云的交易平台示例

基于云的交易环境允许交易者在任何可能的地方工作，从而提供了灵活性和业务连续性。基于云的交易平台通过云平台提供连接，提高了效率，降低了成本。

让我们看一个基于云的交易平台的例子，即 Blueshift 。

https://www.youtube.com/embed/UrzDnv3w3qg?rel=0

Blueshift 是一个免费平台，为每个人带来投资研究、回溯测试和算法交易的机构级基础设施；随时随地。此外，还有一个新推出的 alpha 版本，这是一个快速回溯测试平台，拥有涵盖多个资产类别和市场的分钟级数据。

在 Blueshift 上，在运行回溯测试策略时，您必须明确地选择一个数据集。您必须选择与您的策略一致的数据集。

例如，如果你开发了一个交易苹果的策略，你必须选择纽约证券交易所的数据集来运行它而不出错。目前，我们有以下数据集可用于研究/回溯测试):

  • 美国市场和印度的股票和 ETF 市场数据——公司行动的分钟级别。每天收市后更新一次。
  • NSE(印度)月度期货(前三份合约)的期货数据–分钟级别，含调整。每天收市后更新一次。
  • 外汇数据- 10 种货币对-澳元/美元、欧元/瑞士法郎、欧元/日元、欧元/美元、英镑/日元、英镑/美元、新西兰元/美元、美元/加拿大元、美元/瑞士法郎、美元/日元。分钟级数据每天更新一次。
  • 加密数据- 9 枚硬币兑系绳(USDT)和印度卢比(印度卢比)，也包括 USDT/印度卢比。这九枚硬币分别是 BTC、埃思、阿达、BNB、马蒂奇、XRP、索尔、多特和卢娜。您必须将它们指定成对，要么是针对 USDT(如 BTC/USDT)，要么是针对印度卢比(如 BTC/印度卢比)。

你可以研究你的想法，回测它们，并在 Blueshift 上与你选择的经纪人一起实践你的策略。

Blueshift 上提供实时交易的经纪商有羊驼、FXCM 和 MASTERTRUST。对于票据交易，可用的经纪商有羊驼和福汇。

云计算如何应用在自动化交易系统中？

为了在交易中使用云计算，需要遵循使用云服务所需的步骤。

例如，在交易中使用云服务，Blueshift 需要以下步骤。

  • 第一步-注册！
    你只需要注册并签约创建一个账户。
  • 第 2 步-创建策略 你会得到策略模板来创建你想要的策略。例如，你可以创建一个带有看跌期权和看涨期权的期权策略。此外，您将为该策略命名。
  • 第 3 步-撰写并优化策略
    接下来，你将撰写并优化策略。您将被带到可以编写算法的页面。此外，您可以在同一页面上优化回报和其他指标。
  • 步骤 4 -回溯测试
    现在，您可以输入想要用于回溯测试的数据集、开始日期、结束日期以及算法的资本金额。要运行快速回溯测试，请选择运行。
  • 第五步-上线！
    最后，点击“上线”按钮，您的策略将上线。

零售交易中的云计算

云计算的概念是一种按需自助式互联网基础设施，您可以“按需付费”，按需使用。散户交易者正慢慢涉足这种形式的数字技术，基于云的便利来执行他们的交易策略。

由于云的便利，交易者可以使用云服务来创建新的交易策略，对历史数据进行回溯测试，并在执行交易的同时运行时间序列分析。

有了云计算，他们不用自己构建数据中心基础设施，只要需要，他们就可以测试该策略，如果不成功，他们可以关闭该策略并终止支付相同的费用。

这种通过云租用空间和时间的概念远比创建自己的硬件/软件基础设施更可行。

同样的概念也适用于交易相关软件——交易者可以按需使用和运行的软件即服务(SaaS)。交易策略的分析、研究和测试是零售交易迁移到云的原因。

总之，云不是一个行业或类别，它是一个生态系统。零售交易商正在转向云计算，因为它有助于削减成本、最大限度地利用资源和提高效率，从而在他们的交易策略中产生惊人的产出。

外汇市场中的云计算

外汇市场是交易货币的场外交易市场。这个市场每周 5.5 天，每天 24 小时开放，世界各地的交易者通过计算机网络进行货币交易。

在一个不眠不休的全球市场中，外汇交易员如何利用云服务？拥有自动交易系统的外汇交易员将它们放在经纪人的云上或独立的虚拟专用服务器(VPS)公司。

在交易中使用云计算服务的先决条件

要在交易中使用云计算服务，需要以下技能。

编程；编排

编程语言(Python，R，MATLAB)是任何想要利用技术和计算进步(比如对历史数据进行回溯测试)的新老交易员的先决条件。

回溯测试

因为云计算服务提供回溯测试作为其中一个特性，所以人们必须了解回溯测试策略。回溯测试是使用历史数据测试交易策略的过程，以确定该策略的有效性。

回溯测试结果通常以流行的性能指标来显示战略的性能，如夏普比率和索蒂诺比率。性能指标通常有助于量化风险回报。

参数知识

为了使用云计算服务，交易者必须充分了解可以利用的参数，例如限制损失的止损单。通过这种方式，云服务可以得到最好的利用。

平台知识

了解您正在使用的云平台是如何工作的也很重要。这就要求用户在一个解释平台工作的章节中浏览所有必要的信息。

例如， Blueshift 文档帮助你找到你需要知道的关于这个平台的一切。

此外，作为云平台的用户，需要注意的是，您还应该了解其他方面，例如:

  • 围绕云服务使用的法规
  • 建立工作关系网
  • 数据库ˌ资料库
  • 虚拟化
  • 操作系统

这些是云提供商需要解决的许多问题中的几个，但是作为用户，您需要意识到它们。

在交易中使用云计算的好处

现在让我们讨论一下在交易中使用云计算对用户的好处。好处如下-

可靠性

交易中的云计算提供了可靠性，因为您输入的数据存储在多个服务器上，您的提供商甚至可以将数据存储在多个位置。因此，存储的数据比存储在硬盘上更安全，因为硬盘数据可能会由于格式化、技术故障导致的系统故障等原因而丢失。

成本降低

一些云计算平台是免费的(如 Blueshift ),而另一些(如 Cloud9)价格较低。该成本与硬件、软件、硬件和软件维护等方面的支出进行比较。

灵活性和移动性

云计算为用户提供了灵活性和移动性，因为云服务只需要一个有互联网连接的系统。人们可以从任何地方访问云平台。因此，没有必要让您的系统随时准备好相关软件。

在交易中使用云计算的挑战

在交易中使用云计算的挑战并没有减少，而是可以管理的。让我们看看你需要知道的关于使用云计算进行交易的缺点:

停工期

当你的网络瘫痪时，这是一个缺点。如果你的互联网出现故障，在云上什么也做不了。

安全问题

由于云计算服务可供所有人使用，因此安全性是一个问题。为了确保安全，您必须遵循基本的安全措施，如加密、不与任何人共享您的密码以及备份您的数据(以防万一！)

缺乏专业知识

要使用云计算服务，掌握专业知识是必不可少的，这样你就可以轻松地浏览和利用平台的功能。为了积累专业知识，通读平台文档非常重要。

此外，了解必要的领域也很重要，如编程、市场知识、绩效指标、战略制定等。当专业知识达不到标准时，会导致性能问题。

服从

云平台的用户需要遵守平台制定的规章制度。当用户不遵守规则或合规时，这是一个问题。

构建私有云并管理多个云

这是一个广泛的话题，但围绕构建私有云以及管理多个云存在许多挑战。

构建私有云需要很多先决条件，例如需要设置计算、网络和存储资源，为硬件安装管理软件等。类似地，在管理多个云的情况下，安全问题包括安全和隐私设置的错误配置等。

挑战可能会有所不同，这取决于您在该领域的知识和专业技能、您可用的资源、法规、费用等。

下图来自 Cloudwards 显示了最常见和最紧迫的云安全问题，以及每种问题出现的百分比。

Cloud security concern

Cloud security concern

结论

云计算在全球范围内被广泛使用，以使专业人员的工作更容易、更高效，并具有可靠的设置和更低的成本等优势。通过管理与云计算相关的挑战，人们可以成功地交易、回溯测试并找到在市场中不同情况下实施的正确策略。

尽管云计算在交易中有其公平的好处和挑战，但它正在发展、改进，并朝着成为技术和金融领域的下一个大事件而努力。

要了解更多使用云服务的量化交易，你可以探索这个算法交易课程，它让你深入了解算法交易的世界。它教你所有你需要知道的关于 algo 交易的知识，并且在云平台上使用它。

注:原帖已于 2022 年**128 月 更新，以确保准确性和时效性。

免责声明:股票市场的所有投资和交易都涉及风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。T3】

Rajib Ranjan Borah 应邀作为年度金融峰会的主旨发言人——IIM·卡希普尔

原文：https://blog.quantinsti.com/rajib-ranjan-borah-invited-speak-annual-finance-summit-iim-kashipur/

The Annual Finance Summit IIM Kashipur

一年一度的 IIM·卡希普尔公司峰会。2017 年联合大会于 2017 年 9 月 9 日日和 9 月 10 日举行，包括金融、营销、人力资源、IT、运营和咨询等各个领域的一系列秘密会议。

金融峰会，作为 2017 聚结大会的一部分，为该领域的专家提供了一个与学术界互动的平台，带来了充满活力的思想和知识交流。在峰会的前一章，行业专家就“金融科技对金融服务业的颠覆”的范围和未来进行了多种颜色的讨论。过去的会议见证了来自 SEBI、德意志银行、安永、NSE、BSE 等公司领导人的热情参与。

IIM·卡希普尔的拉吉布·兰詹·博拉

我们的董事 Rajib 是 IIM·卡希普尔年度企业峰会上众多著名演讲者之一。他谈到了行业和监管机构的期望，让学生成为更好的市场参与者，并弥合学术市场模型和实际市场之间的差距。

作为一名受尊敬的小组成员，Rajib 在股票市场的丰富经验以及随后与其他受尊敬的小组成员的讨论带来了思想、框架和市场现实的交流，让学生们坐到了座位的边缘。

总之，对于 QuantInsti 来说，这确实是一个与 IIM·卡希普尔合作的好机会，通过启发下一代交易者来为算法交易和量化金融领域做出贡献。

以下是此次活动的更多图片:

Rajib Ranjan Borah at IIM Kashipur

用 Python 实现交易中的随机森林算法

原文：https://blog.quantinsti.com/random-forest-algorithm-in-python/

作者:沙古塔·塔西尔达

在这个博客中，我们将讨论什么是随机森林，它们是如何工作的，它们如何帮助克服决策树的局限性。

随着机器学习及其技术在当前环境下的蓬勃发展，越来越多的算法在各个领域得到应用。机器学习算法的功能和工作彼此不同，其中一种算法对于某个问题可能比另一种算法更好。机器学习算法不断更新和升级，以扩大其应用范围，并尽量减少其缺点。

随机森林算法就是这样一种算法，旨在克服决策树的局限性。

在这篇博客中，我们将讨论:

在直接跳到随机森林之前，让我们先简要了解一下决策树及其工作原理。

Anchor什么是决策树？

决策树，顾名思义，具有以分支作为节点的层级或树状结构。我们可以通过遍历这些节点来做出某个决定，这些节点是基于对与节点相关的参数的响应而获得的。

然而，决策树存在过度拟合的问题。过度拟合基本上是通过在树中添加越来越多的节点来增加树内的特异性，从而达到某个结论，从而增加树的深度并使其更加复杂。

此外，在这篇博客中，我们将了解随机森林如何帮助克服决策树的这一缺点。

通过我们的 Quantra 课程，学习如何制作决策树利用人工智能技术预测市场和寻找交易机会。

Anchor什么是随机森林？

随机森林是一种使用集成方法的监督分类机器学习算法。简而言之，随机森林由许多决策树组成，有助于解决决策树过度拟合的问题。这些决策树是通过从给定的数据集中选择随机特征而随机构建的。

随机森林根据从决策树收到的最大投票数做出决策或预测。通过大量决策树达到最大次数的结果被认为是随机森林的最终结果。

Anchor随机森林工作

随机森林基于集成学习技术。系综，简单地意味着一个组或一个集合，在这种情况下，是决策树的集合，统称为随机森林。集合模型的准确性优于单个模型的准确性，因为它汇集了单个模型的结果并提供了最终结果。

如何从数据集中选择特征来为随机森林构建决策树？

使用一种称为 bootstrap 聚合或 bagging 的方法随机选择特征。从数据集中可用的特征集中，通过选择带有替换的随机特征来创建多个训练子集。这意味着一个特征可能同时在不同的训练子集中重复。

例如，如果数据集包含 20 个特征，并且要选择 5 个特征的子集来构建不同的决策树，则这 5 个特征将被随机选择，并且任何特征都可以是多个子集的一部分。这确保了随机性，使得树之间的相关性更小，从而克服了过度拟合的问题。

一旦选择了特征，就基于最佳分割来构建树。每个树给出一个输出，该输出被认为是从该树到给定输出的“投票”。输出

哪个获得最大“投票”由随机森林选择作为最终输出/结果，或者在连续变量的情况下，所有输出的平均值被认为是最终输出。

Random Forest Algorithm

例如，在上图中，我们可以观察到每个决策树都投票或预测了一个特定的类。由随机森林选择的最终输出或类将是类 N，因为它具有多数票或者是四个决策树中的两个的预测输出。

Anchor随机森林的 Python 代码

在这段代码中，我们将创建一个随机森林分类器，并训练它给出每日回报。

导入库

In [ ]:

import quantrautil as q
import numpy as np
from sklearn.ensemble import RandomForestClassifier

The libraries imported above will be used as follows:

  1. quantrautil -这将用于从 yahoo finance 获取 BAC 股票的价格数据。
  2. numpy -对 BAC 股票价格执行数据操作，以计算输入特征和输出。如果你想了解更多关于 numpy 的信息，你可以在这里找到。
  3. sklearn - Sklearn 有很多机器学习模型的工具和实现。RandomForestClassifier 将用于创建随机森林分类器模型。

获取数据

The next step is to import the price data of BAC stock from quantrautil. The get_data function from quantrautil is used to get the BAC data for 19 years from 1 Jan 2000 to 31 Jan 2019 as shown below. The data is stored in the dataframe data.In [2]:

data = q.get_data('BAC','2000-1-1','2019-2-1')
print(data.tail())

[*********************100%***********************]  1 of 1 downloaded
                 Open       High        Low      Close  Adj Close     Volume  \
Date                                                                           
2019-01-25  29.280001  29.719999  29.139999  29.580000  29.580000   72182100   
2019-01-28  29.320000  29.670000  29.290001  29.629999  29.629999   59963800   
2019-01-29  29.540001  29.700001  29.340000  29.389999  29.389999   51451900   
2019-01-30  29.420000  29.469999  28.950001  29.070000  29.070000   66475800   
2019-01-31  28.750000  28.840000  27.980000  28.469999  28.469999  100201200   

           Source  
Date               
2019-01-25  Yahoo  
2019-01-28  Yahoo  
2019-01-29  Yahoo  
2019-01-30  Yahoo  
2019-01-31  Yahoo

创建输入和输出数据集

In this step, I will create the input and output variable.

  1. 输入变量:我使用了'(开盘价-收盘价)/开盘价'，'(高-低)/低'，最近 5 天回报率的标准差(std_5)，以及最近 5 天回报率的平均值(ret_5)
  2. 输出变量:如果明天的收盘价高于今天的收盘价，则输出变量设置为 1，否则设置为-1。1 表示买入股票，-1 表示卖出股票。

The choice of these features as input and output is completely random. If you are interested to learn more about feature selection then you can read here.In [3]:

# Features construction 
data['Open-Close'] = (data.Open - data.Close)/data.Open
data['High-Low'] = (data.High - data.Low)/data.Low
data['percent_change'] = data['Adj Close'].pct_change()
data['std_5'] = data['percent_change'].rolling(5).std()
data['ret_5'] = data['percent_change'].rolling(5).mean()
data.dropna(inplace=True)

# X is the input variable
X = data[['Open-Close', 'High-Low', 'std_5', 'ret_5']]

# Y is the target or output variable
y = np.where(data['Adj Close'].shift(-1) > data['Adj Close'], 1, -1)

In [4]:

列车试分裂

We now split the dataset into 75% Training dataset and 25% for Testing dataset.

# Total dataset length
dataset_length = data.shape[0]

# Training dataset length
split = int(dataset_length * 0.75)
split

Out[4]:

3597

In [5]:

# Splitiing the X and y into train and test datasets
X_train, X_test = X[:split], X[split:]
y_train, y_test = y[:split], y[split:]

# Print the size of the train and test dataset
print(X_train.shape, X_test.shape)
print(y_train.shape, y_test.shape)

(3597, 4) (1199, 4)
(3597,) (1199,)

训练机器学习模型

All set with the data! Let's train a decision tree classifier model. The RandomForestClassifier function from tree is stored in variable ‘clf’ and then a fit method is called on it with ‘X_train’ and ‘y_train’ dataset as the parameters so that the classifier model can learn the relationship between input and output.In [6]:

clf = RandomForestClassifier(random_state=5)

In [7]:

# Create the model on train dataset
model = clf.fit(X_train, y_train)

In [8]:

from sklearn.metrics import accuracy_score
print('Correct Prediction (%): ', accuracy_score(y_test, model.predict(X_test), normalize=True)*100.0)

Correct Prediction (%):  52.71059216013344

In [9]:

# Run the code to view the classification report metrics
from sklearn.metrics import classification_report
report = classification_report(y_test, model.predict(X_test))
print(report)

             precision    recall  f1-score   support

         -1       0.52      0.61      0.56       594
          1       0.54      0.44      0.49       605

avg / total       0.53      0.53      0.52      1199

战略回报

In [10]:

data['strategy_returns'] = data.percent_change.shift(-1) * model.predict(X)

每日回报直方图

In [14]:

%matplotlib inline
import matplotlib.pyplot as plt
data.strategy_returns[split:].hist()
plt.xlabel('Strategy returns (%)')
plt.show()

战略回报

In [13]:

(data.strategy_returns[split:]+1).cumprod().plot()
plt.ylabel('Strategy returns (%)')
plt.show()

The output displays the strategy returns and daily returns according to the code for the Random Forest Classifier.

Anchor优势

  • 避免过度拟合
  • 可用于分类和回归
  • 可以处理缺失值

缺点

  • 大量的树木会占用空间，减少时间。

In this blog, we learnt the functioning of the Random Forest Algorithm with the help of an example, along with the Python code to implement this strategy.

通过我们的 Quantra 课程，学习如何使用人工智能技术制作决策树来预测市场和寻找交易机会。

免责声明:股票市场的所有投资和交易都涉及风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。T3】

建议阅读:

随机漫步:简介，GBM，模拟

原文：https://blog.quantinsti.com/random-walk/

由瓦伦·迪瓦卡尔和雷基特·帕查内卡尔

随机游走！当我说这两个字的时候，你会想到什么。如果你想到一个人以这样的方式行走，我们不知道他们下一步会去哪里，那么你离这个概念不远了。但是，一个随机行走的人如何影响我们对做多或做空一只股票的看法呢？

在金融领域，随机游走理论认为，今天的股价对明天的股价没有关系或影响，股价的走向完全是随机的，不可预测的。

等等！这是否意味着所有的技术和定量分析工具都是多余的？虽然随机漫步理论有相当多的支持者，但它的批评者仍然活跃。无论如何，让我们从博客开始，看看我们将在几分钟内涵盖哪些主题。

什么是随机漫步？

如果我必须定义一个随机行走，我会说它是一个随机过程，用来描述一个看似随机或不可预测的物体所走的路径。是的，就是这么回事。

趣闻:有一座由艺术家安东尼·葛姆雷用随机漫步法创作的巨型雕像。请看下面:

图片提供:维基媒体

现实生活中有很多随机游走的例子。它们的范围从一个醉汉不可预测的行走，房间里气体分子的运动，甚至一枚硬币的投掷都可以说是随机的。

****但如果是随机的，我们为什么还要研究它？T3】

让我借助一个简单随机游走的例子来给出这个答案。让我们举一个在概率中经常被滥用的例子，抛硬币。现在我们知道掷硬币有两种结果，正面或反面。如果你扔硬币，你不能确定是正面还是反面，对吗？当然，在 10 次、50 次或者 100 次投掷中，你会发现硬币有 50%是正面朝上的。这就是重点，给定足够的试验，我们试图在一个看似随机的过程中找到模式。这有助于我们研究一个过程，如果可能的话，还可以预测结果。

事实上，让我们更进一步，以股票市场为例。虽然随机漫步可以由连续变量组成，但我们将讨论一个简单的随机漫步模拟。

假设红色公司的股票价格是 100 美元，我们说一个步长是 10 美元。由于随机漫步声明对象的路径是不确定的，并且不依赖于任何东西，甚至不依赖于历史价格，我们可以肯定地知道股票在第二天只能有两个值，增加或减少 10 美元。

因此，如果我们说在 2 月 10 日，如果价值是 100 美元。2 月 11 日，价格可能是 90 美元或 110 美元。

在 2 月 12 日，可能有 4 种结果，90 美元可能变成 80 美元或 100 美元，110 美元可能变成 100 美元或 120 美元。

有意思的是，如果我们尝试以表格形式查看结果，结果会是这样的:

当然，这里我们假设，就像一个硬币，有一个平等的概率，股票价格可以上升或下降。在现实生活中，对于任何随机过程，我们不能肯定地说，一个对象所走的路径的概率是多少。

这里我想补充一个概念，叫做“漂移”。在前面的例子中，我们已经说过两种结果(股票上涨或下跌)的概率相等。我们这样说是因为这应该是一个简单的随机漫步。但在某些情况下，一种结果比另一种结果更重要。当你想到股市的时候，这种“漂移”其实会变得更加清晰。虽然个别股票有些难以确定，但我们可以看到，作为一个整体，股市通常是向上的。因此，我们会说，股票市场正在向相反的方向漂移。

坚持住！我们看到了一个扔硬币的例子，它是一种随机漫步，也是由股价创造的一条路径。但似乎有些不对劲。让我们看看随机漫步是否可以应用于股票市场。

市场中的随机漫步理论

伯顿·马尔基尔在《漫步华尔街》一书中普及了交易中随机漫步的概念。正如我们上面提到的，随机游走理论认为明天的股价不取决于今天的股价。换句话说，我们无法预测未来的股价。

伯顿建立在早期作品的基础上，他说股票市场的运动表现出随机游走，因此，人们无法准确预测未来的价格。他研究了各种投资技术，并批评财务顾问说，我们最好投资于被动的指数基金，而不是真正试图战胜市场。他说，很少有由金融顾问管理的基金实际上跑赢了金融市场。

这里有一个有趣的事实，为了支持他的理论，他告诉他的学生，他们以 50 美元的价格购买了一只假想的股票，然后告诉他们抛硬币，每有一个正面，股票将收盘上涨半个点，反之亦然。抛了几次硬币后，创建的图表交给了一位技术分析师，他看不出这是一个假的图表，并向伯顿发出了买入信号。

同样值得注意的是，他还提到，如果你把飞镖给一只猴子，并告诉他把它们扔向由股票组成的镖靶，它们至少会像财务顾问一样成功。

当然，已经有实验试图模拟这些练习，并得出有趣的结果。这些结果是什么？让我们在下一节看到它们。

对随机漫步的批评

让我在这里提两个实验，乍看之下，这两个实验似乎都支持随机漫步假说，但事实证明并非如此。

在第一个例子中，马克·斯考森首先让他的学生在“金融经济学”课上选择一只表现良好的股票，然后让他的学生向一块有 1000 只股票的木板扔飞镖。到学期结束时，在平均回报后，发现通过投掷飞镖选择的股票组合比精心选择的股票组合表现更好。

如果这说服了你，那就等着听下一个吧。 Research Affiliates 的首席执行官罗布阿诺特(Rob Arnott)也从总共 1000 只股票中随机创建了 30 只股票的投资组合，给所有股票相同的权重，然后根据市场回报来衡量回报。为了确保这是一个随机过程，他将这个过程重复了 100 次，实际上，创造了 100 个随机投资组合。你猜怎么着？其中 96 个投资组合的表现优于基准指数

那是否意味着随机漫步假说是真的？

坚持住！罗恩·阿诺特用简单的方式解释了这种优异表现。宇宙中的 1000 只股票中，小盘股比大盘股多。因此，投资组合中小盘股(高风险但高回报)比大盘股(低风险但低回报)多是很自然的，因此，“随机挑选”的股票投资组合有很大的机会跑赢股票。你可以在这里阅读整个故事。

现在等一下。我们仍然可以说，是的，风险很高，但我们确实跑赢了市场，对吗？

不完全是。正如我们从无数例子中看到的，从长期来看，小盘股提供的回报会逐渐减少，在某些情况下，会急剧减少。因此，从长远来看，这种随机选择的投资组合可能不是一个好主意。

此外，我们知道股票价格会受到各种因素的影响，一个主要的例子是收益公告或关键事件。因此，一个简单的历史分析可以让我们对未来的价格走势有所了解。有趣的是，有些人认为随机漫步是有效市场假说的进一步证明，而另一些人得出结论，当涉及到它们的含义时，他们完全相反。如果我们必须考虑更当前的事件，伯顿实际上已经承认“智能测试”可以用来超越市场，这意味着有可能击败市场。虽然这并不完全相关，但你可以在这里阅读。

但在某种程度上，我们可以使用随机游走假设，并尝试预测股价。在我们看 python 代码之前，让我们先看看几何布朗运动。

几何布朗运动(GBM)

未来的股票价格很难预测，它取决于过去的趋势和波动性。在模拟股票价格时，我们必须给这两个参数合理的权重。随机游走模型有助于整合股票的这两个特征，并以一种非常清晰和简单的方式模拟股票价格。不用说，股票价格是随机的且不可预测的假设是这个模型的核心。让我们首先理解构成我们模拟基础的数学方程:

Xt = μ + Xt-1+ et

其中，X t 是 t 时刻股价的对数，X t-1 是 t-1 时刻股价的对数，μ是漂移常数 e t 是 t 时刻的白噪声

可以看出，除μ外，所有其他项都随时间变化，随机噪声在每个时间步长都会变化。在一个标准的随机漫步中，模型在每个整数时间点的步长为 1，并且有均等的机会上升或下降。在上面的公式中，我们在每个时间步长选择了一个可变的步长。如果我们的步长为√h，时间是 h 的倍数，然后取极限为 h→0，你得到一个布朗运动。如果我们看一下几何布朗运动的定义，它是这样的:

“几何布朗运动(GBM)(也称为指数布朗运动)是一种连续时间的随机过程，其中随机变化量的对数遵循具有漂移的布朗运动(也称为维纳过程)。”

这个定义非常接近于我们开始使用的上述方程，因此，为了模拟本例中的股票价格，我们将使用 St(随机过程)的 SDE 或随机微分方程。

St = St-1* exp((μ-(σ2/2))*t + σWt)

其中 S t 是 t 时刻的股价，S t-1 是 t-1 时刻的股价，μ是日均收益，σ是日均波动率 t 是步长 W 的时间间隔 t 是随机正态噪声。

用几何布朗运动模拟股票价格的随机游走

现在让我们试着模拟股票价格。对于这个例子，我从 2008 年开始收集通用汽车的股票数据。导入库和价格数据的代码如下:

交易爱好者可以阅读的书目

原文：https://blog.quantinsti.com/reading-list-trading-enthusiasts/

扎克·奥克斯

关于交易，我最常被问到的问题是我是如何开始的。唯一真正的答案是尽可能快地开始积累经验。这并不意味着交易 25 个合约期货，但我认为纸上交易对教授订单执行的心理学和力学作用不大。我认为，从小额货币开始，或者慢慢适应股票(或者最近小额期货可能会有一席之地)，是获得资本市场经验的最佳方式，而不会损失你以后可能需要的所有资本。
T3T5

另一个正确的答案，至少对我来说，是阅读我能得到的一切。我是一个相当狂热的读者——我试着每周读 3 到 5 本书——不幸的是，对于我的女朋友来说，大部分书都堆在床边(或床上)。我读了几乎所有我能找到的交易书籍，我的全栈开发者资格大部分归功于通过代码书工作。

这不会是你找到的第一份阅读清单，但是与其把它列成一份恐吓读者的清单，我认为列一份容易理解的阅读清单会更有用。我包括了一本初级、中级和免费的书，里面有定量交易的所有必要内容。这是给有兴趣获得交易经验的人的阅读清单，而不是应用数学博士。如果你有应用数学学位，我会推荐《赫尔》和其他类似的书——但这个列表可能不适合你。

自动化的第一个关键是确保你有所有合适的工具。如果你只是在寻找自动化零售，EasyLanguage 可以是非常通用的，有关于 Tradestation.com 的有用课程/书籍。对于目标是在机构工作的人来说，这至少应该是 Python，最终可能是像 C + +这样的低级语言。目前，目标是可访问所以我们将从 Python 开始，它是必需的组件熊猫。不要犯我在学习 Python 时没有正确学习 Pandas 库的错误——这将使 Python 中的一切都变得困难。

Python 最佳书籍——算法交易基础

初学者:QuantInsti Python 手册(免费)

如果你想读一本书(Python 和 Pandas)，这将是一个很好的选择，因为它有很多你可以应用的直接例子。我希望我在学 Python 的时候有这个参考。

一天之内学会 Python &好好学，Chan

这本书再清楚不过了，如果学习一门新的语言是令人生畏的，我会从这里开始。这应该为以后使用 Pandas、Numpy、Scipy 等库构建更具体的模型提供了一个很好的基础。

熊猫食谱

如果你发现自己每次看到 df 都在叹气，那就帮自己一个忙，把这本书看完。在几章之内，你会有无穷无尽的技巧，甚至是曾经让你沮丧的简单操作。我非常后悔直到最近才看完这本书——对熊猫的舒适是系统交易的必要条件，它对 ML 的重要性不可低估。

中级:Python for Finance(检查 PD 内容)/数据科学

一个优秀的更深入的阅读，直接应用和有用的功能(如蒙特卡罗的，回测等)。还有一个不错的 Pandas 部分，涵盖了查询和过滤功能。我最喜欢的部分是各种 MC 模型，以及优化功能/有效的前沿覆盖。

中级:Python 食谱

可能是我最喜欢的 Python 书籍，极好的食谱，有助于理解元组解包、属性等。阅读这些书总是一种乐趣，没有什么能像烹饪书一样让我真正欣赏编程语言的复杂性——所以你会在我的列表中看到其中的一些。

提及

Python 中编程面试的要素，Aziz

这本书是我面试定量分析师职位时的圣经。事实证明，它对编码挑战非常有帮助——很多时候，这不像你在实践中会做的任何事情。尽可能做好准备是好事，这会让你达到目的(也回顾一下https://www.hackerrank.com，许多基金把这作为筛选工具；并且检查如果公司给你练习题——我意识到有一次公司基本上提前给了我练习题，但是我没有看)

拼图的下一块是资本市场，我将把我最喜欢的资产分类包括进来，尽管对技术交易者来说，它们是相对可互换的(除了期权)。基于这个理论，我决定把它们归类在一起——我的笔记涵盖了大多数书的内容，这应该是相当明显的。

在我开始之前，我想提一下，根据我的经验，你应该忽略任何书名中有“沃伦·巴菲特”的书。大部分人都没有意识到自己的适合度与他相差光年，把他的行为奉为神明。我认为短期内价值投资没什么好处。

日内交易的最佳书籍

初学者:了解股票，了解期权；真诚的

这两本书都介绍了简单和复杂的概念。写得很清楚，报道简短，但足以让你知道你是否想深入研究。这将为您提供对基础知识的全面理解，并为您打下坚实的基础。

高概率交易，链接

我最喜欢的关于期货的书，如此简单，如此有帮助。非常适合初学者和专业人士复习基础知识。包括新交易者经常忽略的心理学部分。我特别喜欢例子中使用的市场广度——期货市场的所有角落，而不仅仅是 es 或 CL。

货币市场日交易和波动交易，留置权

伟大的外汇入门书，提供了有益的理解是什么移动货币和利率。为进入外汇交易和事件套利提供了坚实的基础。

短期交易的长期秘密，威廉姆斯

一个美好的老学校期货书，对初学者来说足够容易，伟大的回测包括一些基本的过滤器。

中级:期权波动性和定价，纳滕堡

我最喜欢的交易书——当我只交易期权时，我每年都会读这本书。这是期权圣经。没有哪本书能让你对期权定价有更完整的理解。

提及:如何以日交易为生，Aziz(伟大的整体交易书)，Naked Forex，Nekritin & Peters(简单、有用、无指标的外汇)，作为战略投资的期权，McMillan(广泛覆盖期权和一些期货市场)。

技术方面最近的趋势是机器学习。老实说，我还没有看到将机器学习应用于 alpha 模型取得多大成功。我可能有 3 个涉及 ML 技术的过滤器，(在大约 320 个策略中)，它们只是现有策略之上的过滤器。尽管如此，如果你的目标是在简历上添油加醋，这对许多基金来说可能很重要。

量化交易中的机器学习

初学者:一百页的机器学习书籍(免费)

对容易混淆的概念有一个基本的了解是很棒的。我发现这本书很有帮助，即使是在阅读了这个列表中的一些更高级的名字之后——只是为了确认这些 ML 概念到底在做什么。

使用 SKLearn、TF Keras 实践机器学习(获得最新版本:TF2.0，更加宽容)

这是一本很好的书，可以让你在与 RFR 和 NN 一起工作时感到舒适。如果你有问题，奥雷连恩会很有帮助，书中的练习虽然具有挑战性，但会让你对内容充满信心。

中级:神经网络&深度学习，尼尔森(免费)

高级 ML 概念的在线演练。非常类似于 ML 上的手。如果你预算有限的话，这应该是一个很好的选择(而且，ThriftBooks 有时在普通教科书上有很多优惠)

高级:金融 ML 进展，普拉多

这本革命性的书颠覆了大多数时间序列研究。一旦你对 ML 有了一个基本的了解，你就一定要去阅读。该领域令人难以置信的发展，即使对于对机器学习不感兴趣的人来说，这也是一本必读的书，因为它深入地覆盖了回测偏差。

我想尽量避免这个列表过于偏颇，所以我要再次说明，我是一名技术交易者，我的偏好倾向于技术分析，只是根据我自己的经验，但我也想在这里包括一些好的基本面书籍。

新手最佳日交易书籍

技术分析大师班

应该对 Prime/Kindle 会员免费；这不是大师课，而是对助教的一个很好的概述。

技术分析，技术人员的完整资源

这本书(和 CMT 的文本)很重要，但是它有每种模式工作频率的统计数据——一个非常有用的指南。我最喜欢的关于技术分析的书——这本书没有什么不深入探讨的。

聪明的投资者，格雷厄姆

价值投资圣经，也许打破了我的沃伦巴菲特规则的过渡财产。如果你打算读一本价值投资的书，这是一本值得一读的书——不需要更高级的东西。

中级:寻找阿尔法，法肯斯坦

这本书回顾了基本因素，并提供了一个基于四分位数的回溯测试(顶部与底部，由 ex 筛选。EPS 增长和 EBITDA 对账面价值)。它提供了一个有价值的指导，为宇宙选择建立基本的过滤器，甚至过滤现有的策略信号。

提到

开创性的投资组合管理，斯文森

(从 99 年到 09 年，他的年平均回报率为 11.9%，为耶鲁捐赠基金提供了 165 亿美元的价值——这已经足够了)

为了把所有的事情联系在一起，有一些很棒的书可以让你了解创造有利可图的交易策略的过程，以及相关的程序。第一本书是我非常钦佩的一个朋友写的，他是许多有抱负的新交易者的好老师——更不用说世界职业棒球锦标赛期货 2x 冠军了。

算法交易书籍

初学者:构建成功的算法交易系统

对战略发展每个阶段的精彩报道；如果你需要读一本书，我会读这本书。Davey 经历了所有的事情，从提出交易想法到回溯测试，甚至监督新系统的实施。戴维最大的贡献是他的交易系统生产指南——它帮助我认识到这是一项持续的工作，总是在改进和发现新的阿尔法。

jae kle-to masini 贸易系统公司

简单的书，提供了系统交易的所有方面的概述。这本书特别有助于提出新的系统思想，也提供了一个很好的投资组合优化技术的介绍。

算法交易

一本关于量化交易的基础书，很好的覆盖了均值回归技术。我对支持均值回归的动量策略的报道有点不以为然，但这可能是因为我个人对动量的偏好。对于定量/算法交易所需的技术和统计模型的介绍——不用再看了。

高级:高频交易，奥尔德里奇

这可能不适用于大多数人，但我发现这是我多年来读过的最有趣的交易书籍之一。为创建 HF 基础设施提供了一个宽松的方法。提供了对低延迟世界的精彩观察，并提供了非常有用的每间隔 Max Sharpe 研究表。

提及

算法交易和 DMA

伟大的书，然而可能不适用。

我想就我认为的“错误”阅读材料提出另一个观点。我相信市场微观结构对理解力学很重要，但是我认为它被高估了。首先，它是不断变化的，你将读到的大部分都是过时的。其次，它在最小化延迟方面最有用，延迟不是零售交易者的领域。如果你没有亚微秒级的延迟，我认为不值得花太多时间。《算法交易和 DMA》是一本很棒的书，但是我认为它的应用不适合这个列表，除非目标是在高频工作。

我还想提供一些我最喜欢的代码书的混合列表，这些书不是 Python 的，所以万一你发现自己像我曾经做过的那样寻求扩展你的视野，你不会意外地购买 Bjarnes Strastroup 的书来学习 C + +(像我曾经做过的那样)。

算法交易的最佳非 Python 书籍

初学者:实用 C + +，Oualline

我通过这篇文章学习了 C + +语言，非常棒。

cy thon:Py 程序员指南，Smith

如果您正在寻找 Python 中的挑战，或者需要加速一些代码，请不要再犹豫。

Matlab，编程和问题解决的实用介绍，Attaway

很棒的介绍 MATLAB 的书，我用这篇课文学习了 MATLAB。

一天之内学会 C#并且学好它，Chan

我最初购买了 C#，发现它对我的初学者水平来说是不可读的，然后带着对 C#的新的热爱在几个小时内完成了这个。完美的 C#开瓶器。

高级:C+ +食谱

我喜欢烹饪书，这本也不例外。

基本 C# 7.0(或 8.0)

堪比实用的 C + +，一本对初学者来说足够清晰的好书。

高性能 C + +

涵盖了像 BOOST 库这样的新增功能，并且工作起来很像一本食谱。

提及

免费:

我希望这份清单对你和对我一样有价值；我甚至无法表达这些标题对我的日常工作有多么大的帮助。我也希望这不是一个令人生畏的任务，因为这不应该是一个一夜之间的过程——要成为一个盈利的交易者，需要花一生的时间来获得技能，最好的部分是学习阶段永远不会真正结束。学习编码的最好方法是打开一个编辑器，开始解决问题，并找到解决方案。这适用于交易的大部分方面，唯一的学习方法是实践——但是希望这些书可以帮助你提供一些背景知识，给你指明正确的方向。

免责声明:这篇客座博文中提供的观点、意见和信息仅属于作者个人，并不代表 QuantInsti 的观点、意见和信息。本文中所做的任何陈述或共享的链接的准确性、完整性和有效性都不能得到保证。我们对任何错误、遗漏或陈述不承担任何责任。与侵犯知识产权相关的任何责任由他们承担。

实际有效汇率(REER):公式，计算，等等

原文：https://blog.quantinsti.com/real-effective-exchange-rate/

由查尼卡·塔卡

实际有效汇率是计算本国货币相对于其他国家货币的强势的有用工具。当 REER 增加时，它表明贸易竞争力的损失。

因此，实际有效汇率的计算有助于您通过考虑包括贸易竞争力在内的有利于贸易的因素来决定交易哪种货币。

REER 是制定政策和考察一个国家经济增长时考虑的一个重要指标。国际货币基金组织、世界银行、国际清算银行等机构提供了 133 个国家的 REER 分析。

让我们通过这篇博客发现一些更有趣的事实和实际有效汇率(REER)的用法，这篇博客包括:

实际有效汇率简介

实际有效汇率(REER)是一国货币相对于一篮子其他货币的加权平均值。这种汇率主要用于确定一个国家的货币相对于其他主要货币的价值。

REER 对一篮子货币中每种货币的通胀影响进行了调整，使其能够衡量一种货币实际可以购买的东西。

过去，REER 被用来理解一种货币相对于其他货币以及自身的表现。这是一个重要的量化工具，交易者应该认识到这一点。

实际有效汇率有助于衡量一种货币相对于其贸易伙伴是否升值。实际有效汇率在短期内是不稳定的，对于日内交易来说不是一个好的指标，但它可以用于具有长期视角的外汇交易策略。

REER 公式

回到 REER 计算，一个国家的 REER 可以通过取其与贸易伙伴之间的双边实际汇率(RER)的平均值，然后使用每个伙伴的贸易分配进行加权，然后根据通货膨胀进行调整来计算。

对于初学者来说，这可能听起来有点复杂，但我们将通过一个例子来讨论 REER 的计算，这将进一步简化。

首先，让我们看看计算实际有效汇率(REER)的公式，它是由印度储备银行给出的:

\[\prod_{i=1}^n = [(e/e{i}) (P/P{i})]^wi \]

在哪里，

  • n =篮子中的国家数量
  • i =篮子中的第 I 种货币
  • e 是印度卢比对国际货币基金组织指数形式的特别提款权的汇率
  • ei 是以指数形式表示的外币“I”对国际货币基金组织特别提款权(SDR)的汇率
  • wi 是外币“I”的权重
  • Pi 是与外币“I”相关的国家的消费者价格指数
  • p 是印度的消费者价格指数(CPI)(印度用 CPI 来调整 REER)

REER 的计算举例

为了计算 6 个国家中每个国家的 REER，我们需要找到以下内容:

  • 6 个国家各自的权重
  • 每个国家的汇率
  • 所有 6 个国家的通货膨胀率

6 个国家各自的权重

我们将通过获取六个篮子国家的贸易量数据来计算“权重”。

2021-22 财年，印度最大的贸易伙伴及其贸易总额(进出口总额)以十亿美元计如下:

| 排名 | 国家 | 出口 | 进口 | 贸易总额 |
| one | 美国 | Seventy-six point one one | Forty-three point three one | One hundred and nineteen point four two |
| Two | 中国 | Twenty-one point two five | Ninety-four point one six | One hundred and fifteen point four one |
| three | 阿拉伯联合酋长国 | Twenty-eight point one | Forty-four point eight | Seventy-two point nine |
| four | 沙特阿拉伯 | eight | Thirty-four | forty-two |
| five | 瑞士 | One point two one | Sixteen point nine | Eighteen point one one |
| six | 德国 | Eight point two one | Thirteen point six nine | Twenty-one point nine |

* in billions of US dollars for the financial year 2021-22 Source: Wikipedia

与这六个国家的贸易总额=(119.42)+(115.41)+(72.90)+(42.00)+(18.11)+(21.9)= 3897.4 亿美元。使用贸易总额参数计算这六个国家的贸易权重如下:

| 国家 | 重量 | 重量百分比(%) |
| 美国 | 119.42/389.74 | Thirty point six |
| 中国 | 115.41/389.74 | Twenty-nine point six |
| 阿拉伯联合酋长国 | 72.90/389.74 | Eighteen point seven |
| 沙特阿拉伯 | 42/389.74 | Ten point seven |
| 瑞士 | 18.11/389.74 | Four point six |
| 德国 | 21.9/389.74 | Five point six |

每个国家的汇率

现在让我们看看六种篮子货币对印度卢比的汇率。为了简化计算，我将每种外币的汇率定为每 10 个印度卢比。例如，10 元人民币= 113.90 印度卢比。

| 国家 | 与印度卢比的汇率 |
| 美国 | Eight hundred and fifteen point zero nine |
| 中国 | One hundred and thirteen point nine |
| 阿拉伯联合酋长国 | Two hundred and twenty-two point zero five |
| 沙特阿拉伯 | Two hundred and sixteen point seven |
| 瑞士 | Eight hundred and twenty-three point six six |
| 德国 | Seven hundred and eighty-seven point five nine |

* exchange rates as of 2022

在这种情况下，我们将欧元/印度卢比视为德国的汇率。在计算汇率值时，这些机构会考虑一段预定时间内的平均汇率。这样做是为了应对外汇市场的每日波动。

此外，实际有效汇率(REER)值通常由国际货币基金组织、各国央行和其他国际机构发布，滞后约 3 个月。

通货膨胀

现在让我们看看 6 个篮子货币和印度的通胀数据。

| 国家 | 消费价格通胀 |
| 美国 | Two hundred and ninety-six point one seven one |
| 中国 | One hundred and three point one |
| 阿拉伯联合酋长国 | One hundred and eight point six two |
| 沙特阿拉伯 | One hundred and seven point six one |
| 瑞士 | One hundred and four point seven seven |
| 德国 | One hundred and eighteen point eight |
| 印度 | One hundred and seventy-four point three |

* CPI values as of 2022 Source: Trading Economics

现在，我们将按照以下步骤计算中国的 REER:

  • 汇率成分= e/e1 = 1/113.90 = 0.00877
  • 通货膨胀部分= P/P1 = 174.3/103.1(印度/中国的 CPI) = 1.690
  • 汇率部分和通货膨胀部分的乘积= 0.00877 * 1.690((e/E1)*(p/p1)]^w1)= 0.0148
  • 最终的实际有效汇率成分=[(e/E1)*(p/p1)]w1=(0.0148)0.296= 0.31875

同样，我们可以对篮子里的其他国家和印度进行这种计算。此外，你可以计算其他国家的 REER。

例如，通过取所有其他国家的实际有效汇率(REER)分量的乘积，我们得到印度相对于一篮子六个国家的总 REER。

此外，如果你发现印度/你自己国家的 REER 与另一个国家相比有所增加，这意味着出口到特定国家的产品变得昂贵，而进口产品变得便宜。因此，这意味着现在的贸易竞争力不大。

同样，当一个印度/你自己的国家的 REER 与另一个国家相比下降时，这意味着该国的出口变得更便宜，进口变得更贵，这也意味着该国的贸易竞争力增加了。

REER 对实际汇率

现在让我们看看 REER 和实际汇率之间的区别。

| REER | 实际汇率 |
| REER 是将一个国家的货币价值与其主要贸易伙伴货币的加权平均值进行比较的衡量标准或工具。 | 实际汇率衡量一个国家的商品相对于另一个国家、一组国家或世界其他地区的商品的价值，以当时的名义汇率计算。 |
| 实际有效汇率的公式是:REER = i=1n [(e/ei) (P/Pi)]wi在哪里，
n 是篮子中国家的数量I 是篮子里的第 I 个货币e 是印度卢比对国际货币基金组织指数形式的特别提款权的汇率
ei 是以指数形式表示的外币“I”对国际货币基金组织特别提款权(SDR)的汇率
wi 是外币“I”的权重
Pi 是与外币“I”相关的国家的消费者价格指数p 是印度的消费者价格指数，印度用这个指数来调整 REER

| 实际汇率的公式是:
e x P / P*
在哪里，
e =每单位本国货币的外币，即名义汇率
P/P* =国内价格/国外价格(以外币表示)

|

REER 对即期汇率

即期汇率是在可能的最早起息日(涉及有价格波动的资产的金融交易日期)将一种货币兑换成另一种货币进行交割的当前价格。

虽然即期汇率是在最早的日期交割，但大多数即期交易的标准结算日是交易日之后的两个工作日。

即期汇率是当前的市场价格，而 REER 是一种货币相对于其贸易伙伴的价值指标。

汇率的类型

有四种主要的汇率可供选择。这四种汇率是:

  • 固定汇率
  • 浮动汇率
  • 钉住浮动
  • 美元化

让我们一个一个地看看每一个的关联性。

固定汇率

可直接兑换成其他货币的汇率称为固定汇率。在固定汇率的情况下，特定国家的中央银行将该国的官方汇率与另一国的货币或黄金挂钩。

这样，固定汇率制度将货币价值保持在一个狭窄的货币区间内。例如，丹麦克朗(DKK)与欧元挂钩，中间价为 746.038 克朗兑 100 欧元。

浮动汇率

当今大多数国家采用的最常见的制度是浮动汇率。最常见的例子是日元、美元、欧元和英镑都属于这一类。

由于汇率浮动，各国中央银行频繁干预，以避免贬值或升值。

钉住浮动

在浮动汇率下，这些货币与特定的价值或货币范围挂钩。挂钩浮动要么定期调整，要么是固定的。

钉住浮动也被认为是爬行带。爬行区间是允许围绕区间中心值波动的速率。此外，固定浮动会定期调整。调整是以受控方式或以预先通知的速率完成的。

例如，香港允许资本自由流动，并将汇率与美元挂钩。

美元化

美元化是一个术语，通常用于特定的非美国国家使用美元作为他们的国家货币。例如，津巴布韦在 2009 年引入了美元化，以减少恶性通货膨胀。然而，津巴布韦中央银行最近排除了津巴布韦回归美元化的可能性。

REER 的工作

在计算实际有效汇率时，将一国货币的相对贸易差额与指数中的每个现有国家进行比较，以计算权重。

汇率决定了特定货币相对于指数中其他主要货币的价值。

REER 表示货币的均衡价值。它衡量国家的贸易能力和进出口状况。

由于 REER 表示消费者购买非本国产品或进口产品所支付的价格，因此它包括进口产品所涉及的关税和其他交易成本。

一国货币的 REER 可以通过加权该国与其贸易伙伴之间的双边汇率平均值来计算，使用的是双方的贸易分配。

根据消费物价指数或单位劳动力成本计算 REER 是最常见的做法。国际货币基金组织根据几乎所有国家的消费价格指数计算 REER，而大多数工业国家则采用基于单位劳动力成本的 REER。

它检测贸易流动的潜在因素，并考虑国际价格的变化。

常见问题

有一些关于实际有效汇率的常见问题，我们在这里回答其中一些。

REER 低于 100 意味着什么？

低于 100 的 REER 指数让出口保持竞争力，进口变得昂贵。

更高的 REER 意味着什么？

更高的 REER 意味着进口更便宜，出口更贵。

REER 适应通货膨胀了吗？

是的。在计算 REER 时，REER 根据通货膨胀进行了调整。

结论

实际有效汇率主要用于确定一个国家的货币相对于其他主要货币的价值。因此，REER 被用来理解一种货币相对于其他货币的表现，以及过去相对于自身的表现。

这就是量化分析师在交易或投资一种货币之前使用 REER 来确定其强度的原因。

如果您希望进一步了解汇率以及如何在市场中获得优势，您可以报名参加外汇自动交易的学习课程。

您将获得关于外汇估值方法的知识，如购买力平价、名义有效汇率和实际有效汇率，并学习使用 Python 在交互式经纪人和 FXCM 上自动进行外汇交易。此外，完成本学习课程后，您可以创建自己的交易系统或使用基于云的交易解决方案。一定要去看看。

免责声明:股票市场的所有投资和交易都涉及风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。T3】

从房地产到算法交易——专业人士的旅程

原文：https://blog.quantinsti.com/real-estate-algorithmic-trader/

人们认为，在职业生涯中努力追求自己的抱负并“调整”自己是一项挑战。这是一个挑战，但并非不可能。

它需要我们最好的品质来推动前进，为未来重塑自我并保持前进。一个很好的例子是吉姆，他做了 20 年的房地产经纪人，不断改变他的学术方向，最终以 T2 金融职业的形式找到了自己的职业。

他就是不放弃。他找到了参与算法交易的最佳方式，找到了 EPAT 和 T2，现在他是一名算法交易员。

对于一个了解房地产市场多年的人来说，今天，他已经在他选择的领域——金融——站稳了脚跟。

他是所有那些有抱负的量化分析师的灯塔，他大胆地指出，不管你来自什么职业，如果你对你想进入的领域有基本的了解，并有像 EPAT 这样的课程来指导、激励和帮助你取得成功，实现你想要的东西从来不是不可能的。

我们为你带来他的一些话，关于他的旅程和他对梦想的追求。

我们与吉姆的对话伍德沃德

告诉我们你自己的情况

我住在加州洛杉矶，目前是一名房地产经纪人，专门从事商业房地产。我在这个行业已经干了 20 年。我在一家小经纪公司工作，这让我可以灵活地拓展业务，在许多不同的领域做出贡献。我是一个终生学习者；我上过多所大学，也多次改变过我的研究领域，从数学到金融再到编程。

房地产很有趣，但我真的渴望进入金融业，最好是在一家小型对冲基金、私人股本集团或交易集团工作。这是促使我调查算法交易中的教育选项的原因，也是我认识 QuantInsti 的原因。

在成为算法交易者的过程中，你遇到了哪些困难，你是如何克服的？

我面临的最大挑战是克服这个障碍，我认为所有的定量分析师都是数学或定量金融学的博士，这是我力所不及的。在与 QuantInsti 的代表和以前的学生交谈后，我确信情况并非如此，通过正确的课程、努力工作和专注的学习，我可以成为一名 quant。这就是我处理 EPAT 课程的方式。

我是通过网上搜索和填写“是的，我有兴趣”表格来了解 EPAT 的。Pawan Mer 联系了我，他和我就课程安排进行了几次交谈，看是否适合我，我是否有资格参加课程安排。他还让我联系以前的学生，了解他们的观点。在与一些以前的学生交流后不久，我意识到并决定 EPAT 适合我。

你会如何描述你的学习经历？

我的学习经历非常出色。自定进度和在线提供了在任何时间和任何时间长度学习的灵活性。还有，把讲课内容录下来可以让你有机会回去重新看一遍。我这样做了好几次，每次我都学到了以前没有学到的新东西。

教员和辅助人员对我的任何问题都非常积极。我提出的问题得到了充分和非常详细的回答。我认为这是一个巨大的好处，因为我知道我可以问任何问题并很快得到答案。

离开 EPAT 后，你的生活有什么变化？

完成 EPAT 课程给了我很大的信心，让我在很短的时间内完成了严格的课程，学到了很多东西。我知道，从 EPAT 项目毕业后，我作为交易员和定量分析师的技能和知识都有所增长，现在我对市场的理解完全不同了。

你有什么想对有抱负的量化分析师说的话吗？

如果你对市场和交易充满热情，不要犹豫，跳进来吧，EPAT 是一个很好的起点。

下一步

你渴望学习算法交易吗？你想自己开始交易吗？你希望提高你现有的技能吗？然后你有机会通过算法交易(EPAT)执行计划学习算法交易的各个方面！

EPAT 教你成为成功交易者所需的技能。它涵盖了统计与计量经济学、金融计算与技术、算法与量化交易等培训模块。现在报名参加 开始你的算法交易职业生涯 。

免责声明:为了帮助那些考虑从事算法和量化交易的人，这个案例研究是根据一个学生或 QuantInsti 的 EPAT 项目的校友的个人经历整理的。案例研究仅用于说明目的，并不意味着用于投资目的。EPAT 项目完成后所取得的成果对所有人来说可能并不一致。

你应该投资算法交易的 5 个理由

原文：https://blog.quantinsti.com/reasons-invest-algorithmic-trading/

由查尼卡·塔卡

由于预编程交易策略的作用，算法交易在今天是一个流行的概念。此外，在算法的帮助下自动化交易执行过程可以使您的交易之旅更快、更准确。让我们找出“你”作为个人应该投资算法交易的五个理由。

你应该投资算法交易的原因是:

热情

你对学习算法交易的热情，即使这意味着从零开始学习，也是驱动你的必要条件。

想学算法交易和热衷于学算法交易是两回事。这里真正重要的是奉献精神和继续学习的意愿，即使这个过程看起来很困难或者有很多新东西要学。

当你从零开始学习之旅时，你可能会遇到困难，但你必须时刻记住，学习算法交易确实很难，但不是不可能。

Learning algorithmic trading from scratch

想象你和上图中的人一样努力工作。这可能是它看起来的样子。但是严肃地说，算法交易确实需要你对学习有强烈的意愿和热情。

建议阅读:3 天算法交易研讨会的完整记录

知识和兴趣

你有教育背景，或者在数学、统计学、编程、机器学习和数据科学等领域有扎实的知识，或者你有兴趣学习这些，这都是一个很好的理由。

你没有必要在算法交易所需的一个或所有核心科目上有正式的教育背景。但是，在进入学习过程之前，如果你有一些核心学科的基础知识，如数学、统计学、编程、机器学习等，这将是有益的。

这并不意味着只有那些有核心科目教育背景的人才应该投资算法交易。但是，上面提到的核心学科之一的学位肯定会给你带来优势。

虽然，即使你没有足够的必修课知识，你仍然可以通过学习专门的课程来开始你的算法交易之旅。

Educational background in subjects meant for algorithmic trading

Educational background in subjects meant for algorithmic trading

进化你的交易

与人工交易相比，算法交易将帮助你提高效率。

投资算法交易的另一个原因是希望从手工交易中获得飞跃。随着人工智能、人工智能、自动化等新技术的出现，世界在不断发展。金融交易部门也不例外。

如果你一直在投入大量的时间和精力进行人工交易，却没有满意的结果，你可能想试试算法交易！或者在手工交易中尝到成功的滋味后，想用算法交易让自己的技巧更上一层楼。

Transition from manual trading to algorithmic trading

Transition from manual trading to algorithmic trading

为了获得优势

如果你在获取先进的技术知识方面反应迅速且充满活力，那么你就能超越他人。

随着技术的变化和进步，算法交易的世界发展迅速，并不断进化。如果你发现自己已经准备好接受这样的挑战并跟上技术的发展，你应该投资算法交易。

算法交易极大地改变了金融市场的交易场景。

Quick and dynamic to advanced technical knowledge

Quick and dynamic to advanced technical knowledge

发展技能

如果你愿意在算法交易上投入大量的时间和精力——通过学习和实践，你可以提升你的交易技能。

毫无疑问，在算法交易中，学习和实践都需要花费大量的时间和精力。考虑到深入研究这个概念所需的奉献精神和意愿，你需要从一开始就做好心理准备。

只要你愿意，从头开始学习算法交易技巧肯定不是不可能的。

Willing to dedicate considerable time and effort to learning and practice

Willing to dedicate considerable time and effort to learning and practice

结论

算法交易是一个值得投资的领域，无论是你的时间、精力还是资金。如果你对金融市场内的交易感兴趣，走算法之路可能对你有益。

然而，在你计划投资算法交易之前，重要的是你要保持你的期望是现实的，并遵循一个实用的方法。

如果你只是想建立算法交易的基础，或者想对这个领域有一个全面的了解，Quantra 关于如何开始算法交易的简短自学课程正是你想要的。只需奉献 3 个小时，收获一生的技能。立即注册！

免责声明:本文提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害负责。所有信息均按原样提供。

为您推荐的 Quant 读物–2016 年最佳！

原文：https://blog.quantinsti.com/recommended-quant-readings-best-2016/

Recommended Quant Readings for you – Best of 2016!

随着 2016 年接近尾声，我们在这里列出了我们博客上的推荐阅读清单，以及由您投票选出的排名最高的博文！享受最后几天做你最喜欢的事情吧！请继续阅读。

算法交易的系统架构

这一条直接来自 QuantInsti 算法交易(EPAT)高管课程的一个讲座。它比较了传统的交易结构和算法交易架构，并强调了后者的复杂性。这篇文章解释了交易服务器的三个核心组件:复杂事件处理引擎(大脑)、订单管理系统(四肢)和数据存储组件。还解释了整个系统的生命周期，以便读者了解当从交易所收到数据包时会发生什么，交易决策在哪里发生，如何监控风险以及如何管理订单。

quants 的回溯测试平台

市场上有许多平台，对于初学者来说，选择最适合他们的平台常常是令人困惑的。这些帖子列出了可用平台的 USP，以便您在开始使用平台进行回溯测试之前做出明智的选择。仔细做出这个决定很重要，因为你需要在一个平台上花足够的时间来适应它！

一个 Pairs Trading quant 项目，一个在 R 中有开源代码的工作策略

在这篇极具洞察力的文章中，QuantInsti 的 EPAT 毕业生雅克·儒贝尔分享了他在 R 编程语言统计套利方面的项目工作。对于对 Excel 比较熟悉的读者，可以在这里下载 Excel 中的一个 pair 交易模型开始使用。他简要地讲述了统计套利的历史，然后用 R 编程语言讲述了这种策略及其降价。

算法交易策略

有哪些不同的 Algo 交易策略？与每个策略相关的策略范例和建模思想是什么？我们如何建立一个算法交易策略？这些是这篇深入文章中回答的一些关键问题。QuantInsti 关于算法交易策略的文章包括以下内容:

  • 基于动量的策略
  • 套利
  • 统计套利
  • 证券市场为调整供求或价格而进行的买卖
  • 基于机器学习

Python 作为 DIY 交易者的编程语言

Python 已经成为算法交易者最流行的编程语言之一。在这组文章中，我们谈到了 Zipline，建立技术指标以及学习 Python 对交易的好处。这些文章是在 Yves Hilpisch 博士主持的关于使用 Python 进行自动化交易的网络研讨会上发表的。今年，我们还邀请了刘辉博士主持了一场关于在 Interactive Broker 的基于 C++的 API 中实现 Python 的网络研讨会。Yves 博士和 Hui 博士是自动化交易领域的两位知名人士，他们加入了 QuantInsti 的 EPAT 杰出教师队伍。

学习机器学习进行交易

机器学习和人工智能是这个时代最受欢迎的技术。随着交易变得自动化，机器学习的重要性对于保持市场竞争力变得至关重要。从获取历史信息到在市场上下单买卖，机器学习是自动化交易不可或缺的一部分，我们已经在博客上详细介绍了这一点。

关于算法交易入门的 5 件事(在印度)

随着算法交易在印度的发展，越来越多的传统交易者和新手想要了解这个利润丰厚的领域。然而，由于市场资源短缺，QuantInsti 决定为想涉足算法交易的业余爱好者撰写一篇非常原始的文章。用 basic 语言解释，这篇文章涵盖了开始算法交易前需要知道的所有事情。

下一步

我们希望听到您的意见——为什么您喜欢“任何”或“全部”。如果你想在 2017 年读一些具体的东西，欢迎所有的建议！

推荐股市模拟器游戏

原文：https://blog.quantinsti.com/recommended-stock-simulator-games/

以重香重香

让我们说，你已经经历了金融市场上的大量资源，并创造了一个你真正有信心的交易策略。然而，当你上网考虑开设一个交易账户时，对该策略是否真的有效有一种挥之不去的怀疑。这正是股票市场模拟器被创造出来的原因。

在市场的最初几年，交易员习惯于在纸上写下他们假设投资的价值，然后跟踪市场走势来检查其盈利能力。因此，这种方法被称为票据交易。

现在，股票市场模拟器给你股票的实时信息，并根据股票市场的规则提供虚拟货币进行交易。这有助于你在没有风险的情况下衡量你的策略的表现。

在把真钱投入市场之前，测试你的策略总是一个好的做法。多亏了技术，我们可以获得实时市场数据，这些数据可以用来制定尽可能接近真实世界的策略。

我们将在下面列出几个流行的股市模拟器。您可以根据自己的偏好或所提供的服务来选择模拟器。请注意，这些模拟器很适合手工交易。一旦你找到一只符合你交易策略的股票，你可以用这些股票市场模拟器来测试你策略的有效性。

华尔街幸存者

华尔街幸存者已经存在了十年，他们一直保持着简单的生活方式。这个交易游戏给你 10 万美元的虚拟现金，你可以用它来买卖股票。它还考虑了经纪费用，以尽可能反映真实世界。它也有不同的联赛，你可以参加，获胜者可以获得现实世界中的现金奖励。

支持的股票交易所:纽约证券交易所

Investopedia 股票模拟器

虽然 Investopedia 已经是一个可靠的金融新闻资源，但它还创建了一个股票模拟器，其中包含美国市场股票的实时信息。除了股票，它也给你投资期权的选择。交易游戏拥有大约 700，000 名用户，是检验你在竞争中的地位的好地方。

支持的股票交易所:纽约证券交易所

投资航班

投资不适合胆小的人。虽然它的用户界面不像其他股票模拟器那样简单，但交易游戏有很多功能，对练习算法交易非常有帮助。你可以选择手动购买股票或自动交易。这里有趣的是，你可以使用自己的策略或者导入 Investfly 提供的少数可用策略之一。这里需要注意的是，如果你想创建自己的策略，你需要花很少的钱升级你的会员资格(每月 19 到 49 美元)。

一旦你对自己的策略有信心，Investfly 会给你一个连接到经纪人并开始实时交易的选项。

支持的股票交易所:纽约证券交易所、纳斯达克、TMX、HKE、NSE、BSE、LSE、EPA:ENX

股票培训师

股票教练是一款 android 应用程序，用户可以使用他们的 Google+或脸书账户登录并在几分钟内开始虚拟交易。交易游戏的界面简单易用，用户可以搜索股票并将其添加到投资组合中。在股票详情中，你可以看到历史股价的图表，以便做出更好的决定。

股票模拟器的优势在于它支持 13 个国家和 20 个不同的交易所。

拥有 3100000 注册用户群的用户要证明自己的勇气，竞争是非常激烈的。

支持的股票交易所:纽约证券交易所、纳斯达克、BSE、NSE、日元等

钱班迪

Moneycontrol 是印度市场的顶级金融资源之一。为了教育金融市场的新手，他们开发了虚拟交易游戏 MoneyBhai，为投资者提供 100 万印度卢比投资印度市场。

股票模拟器的规则很简单，我们将在下面列出。

  1. 用户的投资组合中有 1 亿卢比，当天交易限额是相同的
  2. 买卖交易必须遵循市场，交易量不能大于实际市场
  3. 收取的经纪费取决于执行的交易类型
  4. 如果在任何时候，用户觉得他们想重新开始，投资组合可以重置，用户将再次收到 1 亿卢比

支持的股票交易所: BSE，NSE。

DSIJ 股市挑战

Dalal Street Investment journal 和 Bombay Stock Exchange 为我们当中的爱好者创造了一个简单的交易游戏，让他们尝试并完善他们的策略。除了提供 10，000，000 印度卢比(1 亿卢比)的虚拟现金来建立您的投资组合，这个股票模拟器还提供了一个聊天室，玩家可以在这里讨论各种策略以及哪些股票值得购买或出售。

该社区非常活跃，这要归功于该网站定期举办竞赛，奖励表现最佳者。

这个股票模拟器也可以根据你的玩家类型进行定制，例如，学生、机构或公司。

为了帮助您做出正确的选择，DSIJ 还提供了一些其他功能，例如:

  • 每日要闻摘要
  • 顶级表现者
  • 最新股票价格
  • 库存观察清单

支持的股票交易所: BSE，NSE。

交易员培训师

交易者培训师不像这个列表中的其他人那样是一个实时股票模拟器。这款 android 应用的与众不同之处在于，它通过加载一只匿名股票的历史数据来呈现一个场景，并要求你根据这个场景做出决定。这个决定不是‘长’就是‘短’。

你可以使用不同的技术指标，如 MACD，SMA，甚至布林线。

在初级阶段，你从 25000 美元开始，你的目标是建立一个价值 100000 美元的股票投资组合。

支持的证券交易所:不适用

市场观察

市场观察是另一个股票模拟器，它可以让你交易虚拟美元并磨练你的策略。在这个游戏中，你可以选择你的起始金额，如果你想从不同的用户那里得到意见，还有一个论坛。

支持的股票交易所:美国证券交易所、纳斯达克、纽约证券交易所、OTC-BB

交易游戏

这个股票市场模拟器的目的是告知潜在投资者，并为票据交易提供一个市场演示环境。因此，当你注册一个模拟账户时，你必须通过外汇和股票的简短和信息丰富的讲座，然后回答几个基本问题来赚取练习费。通过这种方式，他们以连贯的方式整合了学习和实践模块。

本模拟器提供以下工具用于演示交易:

  • 22 种最受欢迎的股票
  • 11 种货币
  • 3 个索引
  • 6 种加密货币
  • 7 种高度交易的商品

支持的证券交易所:纳斯达克、纽约证券交易所、法兰克福证券交易所

最佳经纪人

Best Brokers 是一款实用的股票市场模拟器应用程序，起价 2.5 万欧元，为您提供全球约 5 万只股票的实时数据。

尽管它专注于虚拟交易，但它也有一个新闻部分，告诉你金融界正在发生的事情，以及应用程序本身。通过添加朋友的选项，你也可以在交易模拟器中与他们竞争。它还支持加密交易。

支持的证券交易所:法兰克福证券交易所、纽约证券交易所、纳斯达克、

Invstr

Invstr 是一个移动股票市场模拟器应用程序，它试图通过提供股票类别来简化投资。这有助于用户了解同一类别中不同公司之间的相关性。它以 100 万美元开始，但这个应用程序的独特之处在于，你可以与联盟中的其他球员竞争，本月的顶级球员在月底获得现实世界的奖励。

免费版限制你的订单比例为可用资金的 10%，你可以购买一个额外的计划来微调你的交易策略。

一旦你对自己的交易策略有信心，Invstr 有一个链接到经纪人的选项。

支持的股票交易所:纽约证券交易所、纳斯达克、BSE、NSE、日元等

图表游戏

图表游戏是一个股票市场模拟器，帮助你学习如何阅读图表。你会得到一张图表和一些指标，它们可以帮助你更好地了解股票的细节，然后根据你的分析买入或卖出。

这是一个很好的模拟器，可以帮助你提高你的分析能力，帮助你理解什么时候退出交易。

支持的证券交易所:不适用

你可以把在线模拟器想象成交易中博弈理论的变体，我们的决定不会影响现实世界。虽然在线模拟器是练习你的交易策略的一个好的开始，但是有些因素可能很难在游戏中复制。例如，由于玩家得到了一大笔启动资金，他们的风险承受能力以及目标可能会与他们自己辛苦赚来的钱不同。因此，当你从纸上交易转向现实世界时，小心谨慎总是必要的。

有很多久经考验的策略可以根据不同的因素用于不同的金融工具。算法交易包是一个帮助你学习和练习这些策略的课程集。

免责声明:本文中提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害承担任何责任。所有信息均按原样提供。

建议阅读:

Python 中的递归函数

原文：https://blog.quantinsti.com/recursive-functions-python/

作者:普拉奇·乔希

肯·汤普森曾经说过- “我最有效率的一天是扔掉 1000 行代码。”。

我相信，借助于函数，这是可以部分实现的！

你有没有遇到过一个不可理解的，琐碎的程序长度，可能有许多重复的代码行，只是增加了这个谜？冗余从来不受欢迎，因为它违背了编码的基本原则。能够写出清晰、易于理解、可读性高的代码，表明你是一个多么优秀的程序员。在这篇博客中，我们将介绍如何创建、定义和调用递归函数，以及在哪里可以使用这样的函数。

这篇关于“递归函数”的博客将带领你通过一个有用的框架来理解函数的各种属性，尤其是递归函数。通过各种例子，我们将帮助你学习如何创建、定义和调用递归函数。

在这篇博客中，我们将讨论以下主题:

什么是函数？

函数是编程的组成部分之一。征服难以理解的庞大代码的最简单的方法之一就是理解函数的重要性和可用性。函数在数学中已经使用了很长时间。F(x)=x^2是一个函数，其输出将根据 x 的值而变化。

功能是建立在一组特定的指令上，以产生期望的结果。使用函数背后的主要思想是通过将重复的代码放在一起并从中创建一个函数来避免冗余。现在，不用再写代码了，你可以直接调用函数。

为什么有用？可以用在哪里？

毫无疑问，函数在编程中起着至关重要的作用。让我列出几个要点，以便更容易理解用例。不言而喻，在程序中加入函数可以提高程序的可读性。函数给程序一个逻辑结构。可重用性是另一个优势，其中一旦被定义，它可以在同一个程序和其他程序中被多次调用。它还改进了代码的长度，使得测试和调试变得更加容易，并且函数也是可移植的，这意味着它们可以存储在库或。py 文件也可以在不同的程序中使用。这些是函数众多优点中的一部分。

不同类型的功能？

Python 中主要有三种类型的函数:

  1. 内置函数是 Python 提供的一些现成函数，内置于任何 Python 环境中。这些通常是 Python 包和库所共有的。例如，Python 允许您使用max()和min()来查找任意数据集各自的最大值和最小值。

  2. 用户定义的函数是可重用的代码块，是我们到目前为止一直在谈论的定制函数。这些功能帮助我们完成特定的任务。您将在这篇博客中详细了解如何创建这些用户自定义函数。

  3. 匿名函数，也称为 lambda 函数。与用户定义的函数不同，lambda 函数是一个内嵌函数，允许分块构造。我们不会进一步详细讨论这些函数，但是这些函数不像其他两个函数那样有任何命名标识符。你可以在这个博客里读到这个功能。

如何定义函数？

可以说，到目前为止，您一定已经理解了用户定义函数的重要性。现在，让我们学习如何定义和创建一个函数。下面我们提到了几种方式。

  1. 第一步——使用关键字def后跟函数名来定义一个函数。

  2. 第二步——设置一个容易理解的函数名。这个函数名对于任何浏览过你的代码的人来说都是不言自明的。假设您必须创建一个函数来计算斐波那契数列。你可以把名字设为fibonnaci_series，而不是说fib或者fib_ser。左括号后面是传递所需参数的函数名。例如，def fibonnaci_series():

  3. 第三步有四种不同类型的论点:

    1. Default: 如果在调用一个函数时没有分配其他值，但在定义一个函数时已经分配了该值，则该参数采用默认值。默认值是通过使用“=”运算符分配的。比如def class( student_name='John'):。现在，如果你调用函数class()，它将打印'John'。

    2. 必需:参数应该按照正确的位置顺序传递，否则，输出显示错误。例如，你定义了一个函数def class( student_name):，但是你调用了class()。那么，这肯定会显示一个错误，因为函数希望你传递一个参数，而你没有传递任何参数。

    3. 关键字:这些是您在函数中传递的关键字，以便于识别。即使你在定义函数的时候用和你传递的不一样顺序的关键字调用函数，也不会有太大的区别。例如:假设你定义了一个函数类，有两个参数 teacher_name 和 student_name，这两个是关键字。如果每次调用函数时都指定关键字，那么顺序就无关紧要了。比如class(student_name= ‘John’, teacher_name= ‘Ms. Jasmine’)它不会以任何方式影响输出或程序。

    4. 变量个数:当你不确定传递给函数的参数个数时。语法如下:def variable_length(*varargs):

结束参数的最后一个括号后面是参数。最后，使用冒号:结束声明。在这个函数中，你编写程序，最后，你可以用 return，print 或者至少有 pass 语句来结束它。

好吧，就像已经存在的内置函数“max”一样，你决定创建自己的 max 函数来找出三个数字中最大的数字。

In [0]:

def maximum(a, b, c):
 if (a >= b) and (a >= c):
 largest = a
 elif (b >= a) and (b >= c):
 largest = b
 else:
 largest = c
 return largest

如何调用函数？

Once defined, it doesn’t have to be defined again. All you have to do is to call the function. When you call a function you don't need to know what is happening inside but only what it is capable of doing. If we see the function defined in the above cell, the 'maximum' function is capable of finding the maximum of three numbers. You can manipulate the function to find maximum of more numbers as well but this is just for your reference.

假设您希望找到这三个数字中的最大值:100023、1000248、1000362。您所要做的就是将这些数字作为参数传递给函数。

如下所示:

In [0]:

maximum(100023, 1000248, 10012)

Out[0]:

1000248

TADAA！！1000362 是三者中最高的。你将在几秒钟内得到结果。事实上，您可以创建自己的最大值函数，Python 有一个由类似的现成函数组成的扩展库。也可以为复杂的程序建立用户定义的函数。

现在您已经对定义、创建和调用函数的整个过程有了一点概念。对吗？让我们来理解递归函数。

递归函数

递归函数是那些在函数内部调用自身的函数。但是首先，让我问一下，什么是递归？递归是这样一种过程，其中当过程的一个步骤涉及到调用过程本身时，该过程就要经历。在这里，这个过程在过程本身中被重复。经历递归的过程称为“递归”。

简单说，递归函数就是调用自身的函数。递归函数总是要说什么时候停止重复自己。

递归函数分为两种情况:

  1. 基础案例或终止案例
  2. 和，递归情况

对于任何递归函数，区分和识别基本情况和递归情况变得至关重要。基本情况在递归函数中起着至关重要的作用。你会问为什么？基本情况定义了终止。像任何其他在到达并获得输出后停止的函数一样，递归函数不会终止。它变成了一个需要终结的无尽循环。记住基础案例是重要的；否则，您将得不到想要的输出。缺少基本案例会导致意外行为。基本情况是函数停止调用自己，但在递归情况下，函数会再次调用自己。

好的，这是递归函数的基本结构:

In [0]:

def factorial(n):
 # Base case
 if n < 0 or n == 1:
 # The function terminates here
 return 1
 else:
 # Recursive case
 value = n*factorial(n-1)
 return value

阶乘是所有小于或等于 n 的整数的乘积，n 的阶乘表示为 n！。

注意:你可以看到的基本情况是一个条件语句，它是 0 或 1 的阶乘。一旦确定了基本情况，您的函数将不会显示任何错误。阶乘 1 或 0 终止递归，避免无限循环。

递归函数的类型

主要有两种类型的递归函数。调用自身的函数或两个相互调用的函数。调用自身的函数是直接递归的，当两个函数相互调用时，这些函数称为间接递归函数。

直接递归函数

这些函数就是你一直学到现在的递归函数。当一个函数再次调用同一个函数时，你称之为直接函数。阶乘是直接递归的一个例子，如下所示:

In [0]:

def factorial(n):
 if n < 0 or n == 1:
 # The function terminates here
 return 1
 else:
 value = n*factorial(n-1)
 return value

In [0]:

# Returns the factorial of 5
factorial(5)

Out[0]:

120

间接递归函数

在间接递归函数中，两个函数相互调用对方，其中两个函数都必须有一个基格。让我们用流程图来理解。

title

这里，函数 1 调用函数 2，函数 2 又调用函数 2，函数 2 调用第一个函数。这可以用一个例子来解释。假设，你有一个 10 个数字的列表。对于列表中的每个奇数，将数字加 1，对于列表中的每个偶数，将数字减 1。如果数字是 1，输出应该是 2，同样，如果数字是 2，输出必须是 1。您可以使用间接递归函数来解决此类问题，如下所示:

In [0]:

def odd(n):
 if n <= 10:
 return n+1
 n = n+1
 even(n)
 return
def even(n):
 if n <= 10:
 return n-1
 n = n+1
 odd(n)
 return

In [0]:

# Call the function 'odd'
odd(1)

Out[0]:

2

In [0]:

# Call the function 'odd'
even(2)

Out[0]:

1

这只是为了说明的目的。这些功能通常被认为是最不实用的。间接递归的用例并不多种多样，这样的问题甚至可以用单行代码来解决。

迭代与递归

递归和迭代的概念非常相似。两者都重复执行一组指令来获得期望的输出，但只是方法不同。简单地说，递归函数在执行过程中调用自身，使函数能够多次重复自身。迭代函数遵循一组指令，这些指令按顺序重复指定的次数或直到满足某个条件。递归函数通常用于计算机科学，因为它们允许程序员使用最少的代码编写高效的程序。缺点是，如果编写不当，它们会导致无限循环和其他意外结果。这是迭代函数和递归函数的核心区别之一。当时间复杂性是一个问题时，迭代函数是最好的选择，因为迭代的次数是确定的或者可以很容易地确定，而递归函数不是这样。递归函数的代码比迭代函数相对更小更短。

为了更好地理解，请浏览这两个代码块:

In [0]:

# ----- Recursion -----
# Method to find factorial of given number using a recursion function
def recursive_factorial(n):
 if (n == 0):
 return 1
 return n * recursive_factorial(n - 1)

In [0]:

# Call the function 'recursive_factorial'
recursive_factorial(3)

Out[0]:

6

In [0]:

# ----- Iteration -----
# Method to find the factorial of a given number using an iteration function
def iterative_factorial(n):
 product = 1
 for i in range(1, n + 1):
 product = product * i
 return product

In [0]:

# Call the function 'iterative_factorial'
iterative_factorial(3)

Out[0]:

6

递归函数的优缺点:

递归函数的优点是它提高了代码的可读性，增加了清晰度，使它看起来有组织，并降低了时间复杂度。汉诺塔问题使用递归函数比其他任何函数都更好解决。

说到缺点，递归函数比迭代函数慢。当递归深入时，它会导致堆栈溢出。递归中的每一步都有点难以调试。

结论

因此，你已经学习了函数的重要性和可用性，不同类型的函数，如何定义和调用函数，什么是递归函数，递归函数的类型，递归函数和迭代函数的区别。我想建议你应该在你的编码之旅中探索更多并实现这一点。祝你好运！

如果你想学习算法交易的各个方面，那就去看看算法交易的高管课程( EPAT )。课程涵盖统计学&计量经济学、金融计算&技术和算法&定量交易等培训模块。EPAT 教你在算法交易中建立一个有前途的职业所需的技能。立即报名！

免责声明:本文中提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害承担任何责任。所有信息均按原样提供。

Getting Started with Algorithmic Trading Course

分享文章:

*

Python 函数教程:定义、类型、命名空间和范围

left-arrow

Python 中的探索性数据分析

right-arrow

*****

制度变化及其对量化策略的影响，Michael Harris[网络研讨会]

原文：https://blog.quantinsti.com/regime-changes-webinar-michael-harris-8-october-2020/

https://www.youtube.com/embed/S57k78ecBLI?rel=0

2020 年 10 月 8 日星期四

东部时间上午 8:30 | IST 时间下午 6:00 |新加坡时间晚上 8:30

【10 年多机构】

正如人们所说，知识是人生最大的礼物。在庆祝我们成立 10 周年之际，我们策划了这个系列来感谢我们的社区。我们从心底里感谢你，感谢你多年来在我们的旅途中给予我们的爱和支持！

****一场回合赛

演讲介绍了市场复杂性和反身性的概念。它涵盖了美国股票市场和其他地方的具体制度变化的细节。

迈克尔谈到了制度变化如何影响策略的发展，以及交易者可以做些什么来尽量减少数据和策略组合方面的影响。

该教程实际上是实用的，参与者可以在他们的系统上复制。Amibroker 用于网上研讨会期间的分析，Python 代码可下载用于会后练习。

迈克尔还提供了一种新指标的代码，他开发了这种新指标来衡量市场的动量和均值回复动态变化。

与会者收到了一本免费的 pdf 格式的书，这本书是迈克尔创作的，由威利于 2008 年出版。

资源

伪和 AFL 代码:https://www . priceactionlab . com/Blog/2015/08/mo version-indicator/

完整的版本指示器代码:可以在本文末尾的下载中找到。

与本次演讲相关的文章链接，以及免费书籍《盈利能力和系统交易》(2008 年，威利出版)的链接:https://www.priceactionlab.com/Blog/Quantinsti

S 匹克简介

Dr Michael Harris

迈克尔·哈里斯

量化交易者，价格行动实验室博客

迈克尔·哈里斯 30 年前开始交易商品和货币期货。

他是这些书的作者:

  • 价格模式下的短期交易(1999)
  • 基于价格模式的股票交易技术(2000)
  • 盈利能力和系统交易(2008)和
  • 被技术分析愚弄:图表、回溯测试和数据挖掘的危险(2015)

Michael 是 Price Action Lab 博客的作者和 DLPAL 软件的开发者。Michael 拥有两个硕士学位，一个是布法罗 SUNY 大学的机械工程，重点是控制系统和优化，另一个是哥伦比亚大学的运筹学，重点是预测和金融工程。如果你也想学习价格行动交易风格，你必须探索我们关于价格行动交易策略的课程。

下载中的文件:

  • 浸没指示器 python 代码

体制定义:多头和空头的分诊，为什么它简化了工作[研讨会]

原文：https://blog.quantinsti.com/regime-triage-bulls-bears-20-september-2022/

https://www.youtube.com/embed/8cRDdteVHo8?rel=0

Laurent Bernut 带你了解市场机制的概念，以及如何在交易时利用市场机制的变化。

演讲者

洛朗·贝努特 (阿尔法安全资本 CEO)

Laurent Bernut pic

Laurent 在 Fidelity Investments、Rockhampton 和 Ward Ferry 拥有超过 18 年的另类投资经验。在富达的 8 年多时间里，他一直是现代史上最长熊市之一——日本股市——的专职卖空者。

关于 Algo 交易大会 2022

QuantInsti 举办的 2022 年算法交易大会对有抱负的算法交易者来说是一个很好的学习机会。这是您联系您最喜爱的专家并免费获得所有问题答案的机会。

该活动于美国东部时间 2022 年 9 月 20 日上午 9:15(IST 时间下午 6:45)举行。

使用回归模型建立交易系统

原文：https://blog.quantinsti.com/regression-trading-system/

由帕万·杜特

建立交易系统是算法交易中最重要的阶段。这是将我们的想法或知识转化为实际行动的阶段。简单地说，你定义了何时开仓，何时平仓的规则。大多数自动交易系统通过消除交易中的人类情绪和偏见来提供优势。

建立交易系统的理想方法有:

  • 确定最合适的交易主题
  • 创建战略草案
  • 规划你的交易逻辑
  • 回溯测试和前向测试
  • 优化结果
  • 策略验证
  • 实时实施
  • 验证结果

这篇文章一步一步地展示了如何使用回归模型构建一个简单的交易系统模板。我们将在本博客中讨论以下主题:

现在让我们进入建立交易系统的第一步。

确定最合适的交易主题

有许多著名的交易方法，包括动量交易、波动交易、均值回复交易、、趋势跟踪、行为交易、统计套利。

每家公司都有其有利的市场条件、风险偏好和回报。比如特斯拉的股价既然在涨，就说是趋势性的。因此，你将在这里尝试一个趋势跟踪策略。

在进行交易系统开发之前，了解你的兴趣领域和风险偏好是很重要的，这样你才能接受系统的缩减。

简而言之，就是在开始之前知道你能承受什么样的损失。

创建战略草案

选择您的交易风格后，我们将计算出最适合您的交易主题的策略方法。

我们有很多方法可以分析股票市场的模式。分析它们的一些流行方法是基于价格行为的分析、情感分析和/或基于机器学习的建模。在 Quantra 课程中详细学习价格行动交易策略。

为了本文的目的，我们正在建立一个基于回归模型的趋势跟踪系统。

什么是回归分析？

回归分析是一种受监督的机器学习技术，主要用于预测和趋势预测以及金融市场中两种股票/资产之间的相关性。目标是找到距离所有数据点最近的回归曲线。

回归分析中的变量

回归建模通常有两种变量:

  • 独立变量:这些变量与输出变量无关
  • 因变量:该变量依赖于自变量

回归分析的类型

有不同类型的回归分析；一些常见的类型有:

  • 线性回归
  • 逻辑回归
  • 多项式回归
  • 套索回归
  • 岭回归。

因为我们想保持策略简单，所以我们将把重点放在线性回归分析上。

线性回归分析

线性回归有两种类型:

简单线性回归:如果只有一个自变量和一个因变量，线性回归方程就是距离已知因变量最近的直线(线性/直线)。

多元线性回归:如果自变量和因变量多于一个，则回归方程由因变量的线性组合得到。

编码前的先决条件

在编码之前，请确保您熟悉基本概念和 python 概念，例如:

Pandas 数据框和 matplotlib

统计概念

  • 普通最小二乘法(用于建立回归模型)
  • 滚动回归

财务&绩效指标

  • 理解，ROC(变化率计算)，投资组合模拟
  • 理解计算不同指标的逻辑，如胜率、CAGR(复合年增长回报)、提款等。

Python 中的回归建模

我们使用 yfinance API 来获取数据。这种分析是使用每小时的数据完成的。

了解数据 API

我们正在使用雅虎金融 python 包(一些其他的选择将是 alpha vantage，quandl，pandas datareader)。

主要功能如下:

  • yahoo finance.download (ticker，startdate，enddate):这为我们提供了每日数据
  • yahoo finance.download (ticker，startdate，enddate，period="60m "):这为我们提供了每小时的数据。例如:我们使用 2020 年 1 月 1 日至 2021 年 1 月 20 日的 Nifty 50 数据

简单线性回归

我们将使用普通的最小二乘法建立一个回归模型。

Regression Summary

Scatter Plot

Scatter Plot

R 平方是描述线性回归模型有多好的最受欢迎的指标。它通常给出实际数据与回归线有多接近的概念。r 平方值介于 0 到 1 之间，R2 值越大，拟合越健康。

开盘的系数，表示开盘和收盘强正相关。

f 统计量的概率是零假设，“回归系数不显著”的概率。因为概率是零，这表明我们的自变量对性能是重要的。

到目前为止，我们已经使用了一个简单的线性回归模型使用 OLS。该模型似乎不错，现在我们将期待在构建交易系统时扩展这些概念。

您可以尝试改进系统的方法之一是使用滚动回归的概念。

滚动回归

滚动回归是使用前 n 根蜡烛线作为参考，为每根蜡烛线拟合一条回归线。这将让我们发展出一种“向前走”的交易模式。

与移动平均线一样，滚动回归使用前 n 根蜡烛线作为参考来拟合回归模型。

我们将为我们的策略模拟计算滚动线性回归。

使用滚动回归的基于预测的交易设置

这个策略非常简单，计算是为了找到每根蜡烛线的回归拟合度(可以是每天、每周、当天的任何时间框架)。

我们为每根蜡烛线拟合回归线(对于前 n 根蜡烛线，open 作为自变量，close 作为因变量)。

我们通过将当前蜡烛线的开盘价作为输入来预测当前蜡烛线的收盘价。

  • 如果预测收盘价>开盘价，则预测价格可能上涨，我们做多。
  • 如果预测收盘价

从 2020 年 1 月 1 日到 2020 年 1 月 1 日，用于模拟 Nifty 1 小时图的数据。

Performance Summary

Performance Summary

请注意，滑动不包括在内。

该策略是日内策略，因为它只考虑蜡烛开盘价(当前蜡烛开盘价不变)。

我们看到，该战略在 2020 年 1 月至 2021 年 1 月期间表现不错。你可以点击下面的下载按钮浏览 Python 代码。

结论

我们已经在本文中看到了基于预测的模型。当应用于同一数据集的历史数据时，线性回归的概念称为自回归。

自回归是各种时间序列分析模型的基础。你可以在 Quantra 课程交易的金融时间序列分析中了解它们。

文件在下载

基于线性回归的交易系统代码

股票市场的所有投资和交易都涉及风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。T3】

托马斯·斯塔克博士的深度强化学习交易世界[网上研讨会]

原文：https://blog.quantinsti.com/reinforcement-learning-trading-webinar-thomas-starke-22-september-2020/

https://www.youtube.com/embed/H-c49jQxGbs?rel=0

本次网络研讨会已经结束。

2020 年 9 月 22 日星期二

美国东部时间上午 7:30 | IST 时间下午 5:00 |新加坡时间下午 7:30

【10 年多机构】

正如人们所说，知识是人生最大的礼物。在庆祝我们成立 10 周年之际，我们策划了这个系列来感谢我们的社区。我们从心底里感谢你，感谢你多年来在我们的旅途中给予我们的爱和支持！

****一场的较量一场的较量

这是我们#10YearsOfQuantInsti 系列的第二场网络研讨会。

在本次会议中，我们将与 Thomas Starke 博士就深度强化学习 (DRL)进行互动。DRL 非常成功地击败了世界上最难的围棋世界冠军。这个演讲解释了 DRL 的要素，以及如何通过“游戏化”将它应用到交易中。斯塔克博士在牛津大学讲授“计算机模拟”,在量化交易领域非常活跃。他经常在世界各地举办关于算法交易的研讨会和演示。

S 匹克简介

托马斯·斯塔克博士

首席执行官，AAAQuants

Starke 博士拥有物理学博士学位，目前担任澳大利亚领先的自营交易公司 AAAQuants 的首席执行官，领导着该公司的量化交易团队。他还在牛津大学担任高级研究员。

Starke 博士曾在私有贸易公司 Vivienne Court 和高速印刷领域的世界领导者 Memjet Australia 工作过。他曾领导劳斯莱斯公司(英国)的战略研究项目，也是微芯片设计公司 pSemi 的联合创始人。

交易中的强化学习:要素、挑战及更多

原文：https://blog.quantinsti.com/reinforcement-learning-trading/

由伊山沙阿

最初，我们是用机器学习和 AI 来模拟人类的思维方式，只不过快了一千倍！人脑很复杂，但容量有限。这种模拟是人工智能研究的早期推动力。但我们今天已经到了人类对 AI 如何“思考”感到惊讶的地步。一句话完美地总结了这一点，“由谷歌的 DeepMind AI 开发的强化学习算法 AlphaZero 教会了我们下棋是错误的！”

虽然大多数棋手知道国际象棋的最终目标是赢，但他们仍然试图将大部分棋子留在棋盘上。但 AlphaZero 明白，只要能拿下对手的王，它就不需要自己所有的棋子。因此，它的举动被认为是相当冒险的，但最终它们将获得丰厚的回报。

AlphaZero 明白，要实现将死的长期目标，它必须在游戏中遭受损失。我们称之为延迟满足。令人印象深刻的是，在 AlphaZero 之前，很少有人想到以这种方式玩游戏。从那以后，不同学科的不同专家一直在研究如何在他们的研究中适应强化学习。AlphaZero 的这一令人兴奋的成就引发了我们探索强化学习在交易中的应用的兴趣。

reinforcement learning for trading

这篇文章的结构如下。重点是描述强化学习在交易中的应用，并讨论 RL 可以解决的问题，这可能是通过传统的机器学习方法无法解决的。你不会找到任何代码来实现，但有很多例子来启发你探索交易的强化学习框架。

什么是强化学习？

强化学习听起来可能很奇特和先进，但是这种技术的基本概念非常简单。其实大家从小就知道这件事！

当你还是个孩子的时候，你总是会因为在运动或学习上的出色表现而得到奖励。还有，你因为做了像打碎花瓶这样的恶作剧而被训斥或责骂。这是改变你行为的一种方式。假设你会因为先来而得到一辆自行车或游戏机，你会为了先来而练习很多。因为你知道打碎花瓶意味着麻烦，所以你会小心翼翼。这叫做强化学习。

奖励起到了正强化的作用，而惩罚起到了负强化的作用。以这种方式，你的长辈塑造了你的学习。以类似的方式，RL 算法可以通过查看行为的奖励或惩罚来学习自己在金融市场中交易。

像人类一样，我们的代理人通过自我学习来实现成功的战略，从而获得最大的长期回报。这种仅通过奖励或惩罚的试错学习范式被称为强化学习(RL)
——谷歌深度思维

如何在交易中应用强化学习？

在交易领域，这个问题可以用多种方式来表述，比如利润最大化、减少提款或投资组合分配。RL 算法将学习最大化长期回报的策略。

Amazon-share-price-2015-2019

例如，亚马逊的股价从 2018 年末到 2020 年初几乎持平。我们大多数人会认为均值回归策略在这里会更好。

Amazon-share-price-2015-2020

但如果你从 2020 年初开始观察，价格会回升并开始形成趋势。因此，从 2020 年初开始，部署一个均值回复策略会导致亏损。看看前一年的均值回归市场条件，当市场开始形成趋势时，大多数交易者已经退出了市场。

但如果你做多并持有股票，从长远来看会对你有帮助。在这种情况下，为了未来的长期收益，放弃你现在的回报。这种行为类似于文章开头提到的延迟满足的概念。

RL 模型可以从 2017 年和 2018 年获得价格模式，从更大的角度来看，该模型可以继续持有股票，以获得巨额利润。

强化学习和传统的机器学习算法有什么不同？

正如你在上面的例子中看到的，你不需要在每个时间步都给 RL 算法提供标签。RL 算法最初通过试错来学习交易，并在交易结束时获得奖励。然后优化策略以获得最大回报。这不同于传统的最大似然算法，传统的最大似然算法要求在每个时间步或以特定频率进行标记。

例如，目标标签可以是每小时后的百分比变化。传统的最大似然算法试图对数据进行分类。因此，延迟满足问题很难通过传统的最大似然算法来解决。

强化学习的组成部分

考虑到 RL 算法试图解决的更大问题，让我们学习强化学习模型的构建模块或组件。

  • 行动
  • 政策
  • 状态
  • 奖励
  • 环境

行动

这些动作可以被认为是 RL 算法在解决什么问题。如果 RL 算法解决了交易问题，那么操作将是买入、卖出和持有。如果问题出在投资组合管理上，那么行动将是对每个资产类别的资本分配。RL 模型如何决定采取哪种行动？

政策

有两种方法或策略帮助 RL 模型采取行动。最初，当 RL 代理对游戏一无所知时，RL 代理可以随机决定行动并从中学习。这被称为探索政策。稍后，RL 代理可以使用过去的经验将状态映射到行动，以最大化长期回报。这被称为剥削政策。

状态

RL 模型需要有意义的信息来采取行动。这个有意义的信息就是状态。比如你要决定买不买苹果股票。为此，哪些信息会对你有用？嗯，你可以说我需要一些技术指标，历史价格数据，情绪数据和基本面数据。所有这些收集在一起的信息成为状态。由设计者决定哪些数据应该构成状态。

但是为了正确的分析和执行，数据应该是弱预测性的和弱平稳的。数据应该是弱预测的足够简单好理解，但是你说的弱平稳是什么意思？弱平稳意味着数据应该具有恒定的均值和方差。但是为什么这很重要呢？简短的回答是，机器学习算法在静态数据上运行良好。好吧！RL 模型如何学习将状态映射到要采取的动作？

奖励

奖励可以被认为是你想要从你的 RL 系统中获得的最终目标。例如，最终目标是创建一个有利可图的交易系统。然后，你的回报就变成了利润。或者它可以是最佳风险调整回报，那么你的回报就变成夏普比率。

定义奖励函数对于 RL 模型的性能至关重要。以下指标可用于定义奖励。

环境

环境是允许 RL 代理观察状态的世界。当 RL 代理应用动作时，环境对该动作起作用，计算奖励并转移到下一个状态。例如，环境可以被认为是一个国际象棋游戏或交易苹果股票。

RL 代理

代理是 RL 模型，它接受输入特征/状态并决定要采取的动作。例如，RL 代理将 RSI 和过去 10 分钟的回报作为输入，并告诉我们是否应该做多苹果股票，或者如果我们已经做多，则平仓。

让我们把所有的东西放在一起，看看它是如何工作的。

Reinforcement-Learning-Model

第一步:

状态&动作:假设 2020 年 7 月 24 日苹果收盘价为 92 美元。基于状态(RSI 和 10 天收益)，代理给出了买入信号。

环境:为了简单起见，我们说订单是在下一个交易日，也就是 7 月 27 日开盘时下单的。订单金额为 92 美元。因此，环境告诉我们，你在 92 美元时做多了一股苹果股票。

奖励:没有奖励，因为我们还在交易中。

第二步:

状态&动作:使用最新的价格数据创建系统的下一个状态。7 月 27 日收盘时，价格达到了 94 美元。代理将分析状态并给出下一个动作，比如卖给环境

环境:将发出一个卖出指令，这将平仓多头头寸

奖励:给代理商 2.1%的奖励。

| 日期 | 收盘价 | 动作 | 奖励 (%回报) |
| 7 月 24 日 | $92 | 购买 | - |
| 7 月 27 日 | $94 | 出售 | Two point one |

太好了！我们已经了解了 RL 模型的不同组成部分是如何组合在一起的。现在让我们试着理解 RL 代理如何采取行动的直觉。

Q 表和 Q 学习

Q 表和 Q 学习可能听起来很奇特，但它是一个非常简单的概念。

在每个时间步，RL 代理需要决定采取哪个动作。如果 RL 代理有一个表，可以告诉她哪一个动作会给出最大的回报，那会怎么样呢？然后只需选择该动作。这个表是 Q 表。

在 Q-table 中，行是状态(在这种情况下是天数)，动作是列(在这种情况下是持有和卖出)。该表中的值称为 Q 值。

| 日期 | 出售 | 按住 |
| 23-07-2020 | Zero point nine five four | Zero point nine six six |
| 24-07-2020 | Zero point nine five four | Zero point nine eight five |
| 27-07-2020 | Zero point nine five four | One point zero zero five |
| 28-07-2020 | Zero point nine five four | One point zero two six |
| 29-07-2020 | Zero point nine five four | One point zero four seven |
| 30-07-2020 | Zero point nine five four | One point zero six eight |
| 31-07-2020 | Zero point nine five four | One point zero nine |

根据上面的 Q 表，在 7 月 23 日，RL 代理将采取什么行动？是的，没错。将采取“持有”动作，因为其 q 值为 0.966，大于卖出动作的 q 值 0.954。

但是如何创建 Q 表呢？

让我们在一个例子的帮助下创建一个 Q 表。为简单起见，让我们以 2020 年 7 月 22 日至 7 月 31 日的价格数据为例。我们添加了百分比回报和累积回报，如下所示。

| 日期 | 收盘价 | 百分比回报 | 累计收益 |
| 22-07-2020 | Ninety-seven point two |
| 23-07-2020 | Ninety-two point eight | -4.53% | Zero point nine five |
| 24-07-2020 | Ninety-two point six | -0.22% | Zero point nine five |
| 27-07-2020 | Ninety-four point eight | 2.38% | Zero point nine eight |
| 28-07-2020 | Ninety-three point three | -1.58% | Zero point nine six |
| 29-07-2020 | Ninety-five | 1.82% | Zero point nine eight |
| 30-07-2020 | Ninety-six point two | 1.26% | Zero point nine nine |
| 31-07-2020 | One hundred and six point three | 10.50% | One point zero nine |

几天前你买了一支苹果股票，现在你已经没有资本了。你只有两个选择:“持有”或“卖出”。作为第一步，您需要创建一个简单的奖励表。

如果我们决定持有，那么在 7 月 31 日之前我们不会得到任何奖励，到最后，我们会得到 1.09 英镑的奖励。如果我们决定在任何一天卖出，那么回报将是到那天为止的累积回报。奖励表(R-table)如下图所示。如果我们让 RL 模型从奖励表中选择，RL 模型会卖出股票，得到 0.95 的奖励。

| 状态/动作 | 出售 | 按住 |
| 22-07-2020 | Zero | Zero |
| 23-07-2020 | Zero point nine five | Zero |
| 24-07-2020 | Zero point nine five | Zero |
| 27-07-2020 | Zero point nine eight | Zero |
| 28-07-2020 | Zero point nine six | Zero |
| 29-07-2020 | Zero point nine eight | Zero |
| 30-07-2020 | Zero point nine nine | Zero |
| 31-07-2020 | One point zero nine | One point zero nine |

但预计 7 月 31 日价格将升至 106 美元，涨幅为 9%。因此，你应该持有股票，直到那时。我们必须表现这些信息。以便 RL 代理可以做出持有而不是出售的更好决定。

如何着手呢？为了帮助我们，我们需要创建一个 Q 表。你可以从将奖励表复制到 Q 表开始，然后使用贝尔曼方程计算每天持有行动的隐含奖励。

贝尔曼方程

\[Q(s_t,a_t^i) = R(s_t,a_t^i) + \gamma Max[Q(s_{t+1},a_{t+1})] \]

在这个等式中， s 是状态， a 是时间 t 的一组动作， ai 是该组动作中的一个特定动作。r 是奖励表。 Q 是状态动作表，但它会随着我们通过经验对系统了解的增加而不断更新。γ是学习率

我们将首先从 7 月 30 日的保持行动的 q 值开始。

  1. 第一部分是采取行动的回报。如 R 表所示，它是 0
  2. 我们假设γ = 0.98。第二天，即 7 月 31 日，卖出和持有操作的最大 Q 值是 1.09
  3. 因此，7 月 30 日持有行动的 q 值为 0 + 0.98 (1.09) = 1.06

这样，我们将为 Hold 列的其他行填充值，以完成 Q 表。

| 日期 | 出售 | 按住 |
| 23-07-2020 | Zero point nine five | Zero point nine six six |
| 24-07-2020 | Zero point nine five | Zero point nine eight five |
| 27-07-2020 | Zero point nine eight | One point zero zero five |
| 28-07-2020 | Zero point nine six | One point zero two six |
| 29-07-2020 | Zero point nine eight | One point zero four seven |
| 30-07-2020 | Zero point nine nine | One point zero six eight |
| 31-07-2020 | One point zero nine | One point zero nine |

RL 模型现在将选择保持动作以最大化 Q 值。这就是 Q 表背后的直觉。这个更新 Q 表的过程叫做 Q 学习。当然，我们采用了一个动作和状态有限的场景。在现实中，我们有一个大的状态空间，因此，建立一个 q 表将是耗时的，也是资源的限制。

要克服这个问题，可以使用深度神经网络。他们也被称为深度 Q 网络或 T2 DQN T3。深度 Q 网络从过去的经验中学习 Q 表，当给定状态作为输入时，它们可以为每个动作提供 Q 值。我们可以选择具有最大 Q 值的动作。

如何训练人工神经网络？

我们将使用体验回放的概念。您可以将代理过去的经历存储在重放缓冲器或重放存储器中。用通俗的语言来说，这将存储状态、采取的行动以及从中获得的奖励。并使用这种组合来训练神经网络。

主要挑战

在构建 RL 模型时，主要有两个问题需要考虑。它们如下:

第二类混沌

这可能感觉像科幻小说的概念，但它是非常真实的。当我们训练 RL 模型时，我们是孤立工作的。在这里，RL 模型没有与市场互动。但一旦部署，我们不知道会对市场产生怎样的影响。

2 型混沌本质上是当一个情境的观察者有能力影响情境。在训练 RL 模型本身时，这种影响很难量化。然而，可以合理地假设 RL 模型即使在展开时仍在学习，因此将能够相应地自我校正。

金融数据中的噪声

有些情况下，RL 模型可能会拾取通常出现在财务数据中的随机噪声，并将其视为应采取行动的输入。这可能导致不准确的交易信号。

虽然有消除噪声的方法，但我们必须小心权衡消除噪声和丢失重要数据之间的关系。

虽然这些问题绝对不容忽视，但有各种解决方案可以减少这些问题，并在交易中创建更好的 RL 模型。

结论

在介绍组成强化学习系统的组件时，我们仅仅触及了强化学习的表面。下一步将是通过实现你自己的 RL 系统来推进这种学习，在真实世界的市场数据上对回测和票据交易。

您可以注册深度强化学习课程，详细学习 RL 模型，并创建自己的强化学习交易策略。

点击查看。

参考资料和进一步阅读

  1. 金融市场中的强化学习——一项调查
  2. 深度 RL 中的关键论文
  3. 来自 DeepMind Technologies 的深度 RL
  4. 优化交易执行的 RL
  5. 增强 Q-Learning 实现最优资产配置
  6. 交易系统和投资组合的强化学习

行业更新

  1. 人工智能和机器学习在算法交易中获得动力& ATS 在波动中
  2. 加拿大皇家银行资本市场推出人工智能电子交易平台 Aiden

免责声明:股票市场的所有投资和交易都涉及风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。T3】

一家国际对冲基金的研究顾问:本如何使其成为可能

原文：https://blog.quantinsti.com/research-consultant-international-hedge-fund-ben/

对知识的探索打开了新的视野，给人带来了新的机遇。一个人在扩展知识的道路上遇到的挑战，提供了新的经验来学习，从而使一个人能够爬上成功的阶梯。

Ben Mignano 就是这样一个人，他不断寻求扩展知识的方法，这帮助他抓住了在国际对冲基金 WorldQuant 担任研究顾问的绝佳机会。

以下是我们与本·米格纳诺先生的对话！

  • Hi Ben, tell us about yourself.

嗯，在过去的六年里，我一直从事算法开发和日内交易。在那段时间里，我接受了编程以及许多不同软件平台和系统的培训和教育。我精通 C++、Java 和 Python 编程语言。

  • When did you start trading?

我从 2005 年开始交易。

  • What prompted you to learn algorithmic trading?

当我开始交易时，我被算法交易所吸引，并且非常想知道程序是如何进行交易的。于是，这段爱情就从 MQL 的名言开始了。

  • What made you decide that EPAT is the ideal choice to achieve your goals and improve your trading skills?

大约一年半前，我在寻找可能的方法来拓宽我的算法交易教育，这一探索导致了 QuantInsti。然后我发现 QuantInsti 在教授个人成为成功的算法交易者的整个过程方面非常彻底。

  • Do you face any challenges? If yes, how did you overcome it?

在整个学习过程中，我不得不克服的挑战是失去收入，这扰乱了我对学习的专注，在解决了我的财务问题后不久，我就控制住了学习。

  • What do you think is the most characteristic of EPAT? What is your experience?

促使我更加渴望完成 EPAT 教育的因素是使用名为 Anaconda 的 Python 软件。在那里，我学到了 Python 和 R 的知识，并开始开发用算法进行市场交易的软件。从那以后，我的兴奋从未减弱。

  • After EPAT station, how was your journey and what are your future plans?

作为一名 EPATian 人，我发现自己充满了机遇，并在一家国际对冲基金公司 WorldQuant 找到了一份研究顾问的工作。这是一份很棒的“工作”，因为这是一份远程工作，而且我可以获得奖金。

  • Do you have any information you want to share with aspiring algorithm traders?

算法交易很棒，在未来 10 年里，它只会越来越强。我很高兴我已经采取了必要的步骤，带着一项被视为迷人和繁荣的技能驶向未来。

Ben 对知识的渴求帮助他成功地完成了算法交易的课程，提高了他的交易技巧，并最终获得了职位。

EPAT 通过其全面的课程和实践培训，帮助任何希望进入算法交易和量化交易领域的人，让他们具备在这一领域取得成功所需的必要技能和知识。它包括统计学&计量经济学，金融计算&技术，机器学习等主题，以确保人们获得算法交易的整体知识。

免责声明:为了帮助正在考虑从事算法和量化交易的个人，本案例研究是根据 quantin STI EPAT 项目的一名学生或校友的个人经历整理的。案例研究仅用于说明目的，并不意味着用于投资目的。EPAT 项目完成后取得的结果对所有人来说可能并不一致。T3】

人工智能和新闻情感在金融中的应用[研究报告]

原文：https://blog.quantinsti.com/research-presentations-29-september-2020/

https://www.youtube.com/embed/FE76PQFJytU?rel=0

议题 1:肖乔博士的信用风险建模

深度学习可以用来定价和校准信用风险模型。深度神经网络可以高度准确地学习结构和简化模型。对于复杂的信用风险模型，其封闭形式的解决方案不可用，深度学习提供了概念上简单且更有效的替代解决方案。

肖博士提出了一种结合深度学习和无迹卡尔曼滤波器的方法来校准历史数据上的信用风险模型，其简化模型的 R 平方达到 98.5%，结构模型的 R 平方达到 95%。

https://www.youtube.com/embed/n_iN8sQhIns?rel=0

主题 2:钱德拉塞卡教授的长期企业估值预测

该演讲侧重于预测使用先进的机器学习和自然语言处理技术的公司的长期企业价值。与市值相比，企业价值提供了更好的公司估值。市值的主要焦点是股东价值，而企业价值取决于长期债务和手头现金。

为了获得 EV，我们将增加长期债务市值，并扣除手头现金。在滚动的基础上预测长达 6 个月的长期企业价值将有助于投资者、评级公司获得其投资增长的长期视图，也有助于管理风险。

2020 年 9 月 29 日星期二

美国东部时间上午 8:30 | IST 时间下午 6:00 |新加坡时间晚上 8:30

【10 年多机构】

正如人们所说，知识是人生最大的礼物。在庆祝我们成立 10 周年之际，我们策划了这个系列来感谢我们的社区。我们从心底里感谢你，感谢你多年来在我们的旅途中给予我们的爱和支持！

演讲者简介

肖乔博士

(帕拉康科技联合创始人)

肖是帕拉康科技公司的联合创始人。他的研究兴趣包括资产定价、金融计量经济学、投资、商品和回报可预测性。他的研究被《福布斯》、《CFA 协会》和《机构投资者》报道。

他是《投资组合管理杂志》和《全球商品应用研究文摘》的编辑委员会成员。他在芝加哥大学获得了金融学博士学位，在那里他是诺贝尔奖获得者尤金·法玛的助教。

钱德拉塞卡教授

(IFIM 商学院商业分析主任)

钱德拉塞卡教授自 2013 年 11 月起担任 IFIM 商学院高级教授兼商业分析主任。他在新德里 FORE 管理学院担任了大约 14 年的主任教授。

在此之前，他在勒克瑙的印度管理学院工作了大约十年(1988-1998)，担任计算机和信息系统领域的教授。他拥有坎普尔 IIT 大学的电子工程学士学位、计算机科学硕士学位和美国佐治亚大学的定量与信息系统博士学位。

从零售交易到算法交易——一个电气工程师的故事

原文：https://blog.quantinsti.com/retail-trader-electrical-engineer-epat-success-story-vilvamoorthy-tamildoss/

“散户交易者有可能转向算法交易吗？”
这是我们经常被问到的问题。

今天，我们带给你的是以巴提安的故事。他在 IT 行业总共有超过 17 年的工作经验，是一名 T2 电气工程师和 T4 认证的 SCRUM Master。

Vilvamoorthy 本人是一名散户交易者，他对各种编程语言有着丰富的经验和知识，并且相信不断提高自己的技能。

他形容自己是:

在软件编程、端到端程序交付、产品开发、系统设计工程&集成、战略规划、应用程序开发、维护&支持和流程改进方面拥有近 14 年经验的专业人才。

我们通过电话采访了他，以了解他在这一领域的历程和经历，以便与您分享。讨论是这样进行的。

嗨，给我们介绍一下你自己吧！

epat alumnus vilvamoorthy tamildoss

我是来自本地治里的电气工程师。在我的职业生涯中，我参与过多个项目，扮演过不同的角色。我在 IT 行业工作了 14 年，经历了产品生命周期的所有阶段，从编码、测试到部署。我喜欢踢足球。

我花了很多时间来发展我的技能。

既然你来自技术领域，是什么让你冒险进入算法交易？

我大学毕业后想找一份软件行业的工作。但是环境让我在本地治里的销售领域工作。在那之后，我进入了软件业 - 我非常擅长数学，这是编码的必备技能。现在，已经过去 14 年了，我一直在与不同的组织合作多个 it 项目。

这些年来，我相信我的销售技能和我的技术技能一样有价值。

我在 2010 年开始调查股票市场。我最初自学如何交易，我认为自己是一个散户。2016 年左右，我开始深入挖掘，发现一个叫做算法交易的系统已经进化出来了。

我有技术背景，已经是一名 C++开发人员，精通许多其他编程语言，我想把它转化到算法交易领域。我做了更多的研究，发现我的技能非常适合这个领域【QuantInsti 是唯一在算法和量化交易领域提供高质量培训的公司。

我以前做过数据科学家，这需要 Python 知识。当我学习算法交易时，我的编程经验真的派上了用场。

我觉得我已经充分理解了技术方面，现在，我正专注于构建策略。我在加密和外汇市场做兼职交易。

我想将来开一家自营交易公司。这就是我投入所有时间和资源学习算法交易的好处。这是我非常了解的一个领域。

我有信心，凭借我以前的编程经验和我在 EPAT 学到的所有技能，我可以创建一个成功的交易平台。

到了一定年龄后，我真的不能满足于一份工作，我想开始自己的事业。

EPAT 在你的职业生涯中扮演了什么角色？

我在网上查看资源，我找不到任何有条理的东西。我过去常常观看解释不同概念的视频，但在加入 Quantinsti 之前，我无法了解全貌。

有了 QuantInsti，信息得到了很好的组织和传递。这种情况在其他课程中很少见——我查过他们中的几门，他们的课程中总是有间隙。

EPAT 的课程结构非常好现在我对整个过程有了很好的理解，从策略制定到实施。

起初，我对参加这个课程持怀疑态度，因为我不知道我花的钱是否物有所值。这么多年过去了，回想起来，我在这门课程上投入的一切都证明是完全值得的。QuantInsti 提供的最新课程材料和支持非常好，事实上，我会说这非常好，我非常感谢。

我加入 QuantInsti 的最大动机之一就是你们开发的网络。

我研究了教员和你们的管理团队，发现你们大多数人都是行业从业者。支持团队确保我被引导通过 algo 领域，我说保密，现在他们交付。

EPAT 校友网络，尤其是 T2 的终身课程意味着很多。课程会根据最新课程的信息进行更新，我也可以接触到该领域的最新发展。

你认为 EPAT 最好的特征是什么？

多亏了 EPAT，我学会了交易系统的整个基础设施。关于进场系统、匹配系统和市场建立软件的讲座对我来说非常有价值。

现在，当我建立策略时，我会查看数据，并通过一些统计分析来运行我的策略，以查看首选结果的概率。

作为一个散户，我过去交易没有任何固定的流程。向 EPAT 学习后，我有了一个用正确的流程进行交易的结构化方法。

你会给有抱负的算法交易者什么信息？

我想告诉人们的一件事是，无论他们获得什么知识，重要的是他们要应用它。

如果不付诸实践，学习就没有任何意义。

你对建立自己和你的技能的渴望和同情是非凡的，Vilvamoorthy。我们确信，许多散户会从你的故事中寻找灵感。我们祝你未来一切顺利。

算法交易(EPAT) 的高管课程是一门综合课程，涵盖从统计学&计量经济学到金融计算&技术，包括机器学习等等。开始你的探索，与 EPAT 一起提升你的算法交易知识。点击这里查看。

免责声明:本文提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害负责。所有信息均按原样提供。

70 岁成为 Quant | Efueyo 的西班牙之旅

原文：https://blog.quantinsti.com/retired-engineer-quant-quantra-success-story-efueyo/

Efueyo 可能是一名退休的机械工程师，但他将退休视为新旅程的开始。Efueyo 是那些少有的从不停止学习并跟随自己的好奇心去实现学习和成长目标的人之一。

他最近尝试开发系统交易策略的旅程让他探索了 Quantra 的算法交易。Efueyo 与我们分享他的经验。

你好，

我是 Efueyo，来自西班牙。我是一名 71 岁的退休人员，致力于学习和钻研这个令人兴奋的计算和编程世界。

在我的职业生涯中，我的专业是机械，专门从事故障分析和延长设备寿命，这些活动涉及许多数据的处理和分析。在我那个时代，可用于这方面的工具非常有限。退休后，我可以致力于学习这门科学。

我给自己设定的目标是制定一个保守的投资策略，其主要目标是在股票市场最不利的情况下保护最初投资的资本，并克服通货膨胀至少“X”点。

多亏了 Quantra 的课程，我在 Python 方面一直在进步。这门课程结构严谨、实用且易于掌握。这对那些没有很高水平的 Python-Jupyter 知识的人非常有益。这对于进入像 Numpy，Pandas 和 matplotlib 等包是非常有用的。

谢谢你给我这个机会，帮助我更接近我的目标。

谢谢你和我们分享你的故事，Efueyo。如果一个人保持好奇心并跟随他们的本能，看看他能取得什么成就，这确实是一种激励。我们很高兴能成为你学习之旅的一部分。

Quantra 课程旨在帮助您从任何级别开始进步。无论你是初学者还是专业的 Quantra，Quantra 上都有一门课程可以帮助你提高技能。立即注册！

免责声明:本文提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害负责。所有信息均按原样提供。

探索 Ripple 和 XRP:它是什么，功能和更多

原文：https://blog.quantinsti.com/ripple-xrp/

今天，我们来看看区块链和加密货币菜单上的一个热门产品——Ripple 和它的加密货币 XRP。它是十大加密货币之一，市值超过 280 亿美元。

加密货币是最近的热门话题。它们具有破坏性，令人兴奋。在本系列的最后几篇博客中，我们探索了区块链的技术。我们仔细研究了两种主要的加密货币，比特币和以太坊，它们导致了加密货币世界的一些重大变化。

在这篇博客中，我们将讨论以下主题:

什么是涟漪？

正如我们在之前的博客中了解到的，像比特币和 T2 以太坊这样的加密货币利用了区块链技术的力量。他们通过使用互联网转移价值带来了重大突破。

然而，由于处理交易的时间较长，它们无法与传统的金融交易系统相比，如 SWIFT 。因此，加密货币在交易中缺乏主流接受度。这就是 Ripple 出现的地方！

最初，国际金融体系支离破碎。众多金融机构在不和谐的环境中工作，导致支付过程容易出错和延迟。

Ripple 试图改善现有的银行系统，而不是破坏它。Ripple 的目标是银行和金融机构使用 RippleNet 以低成本进行通信和交易。RippleNet 是一家区块链企业，使用 XRP 分类账和其本地加密货币 XRP 在全球范围内提供更快的支付。

因此，与公开区块链的比特币和以太坊不同，RippleNet 是一个由独立银行和支付提供商组成的去中心化网络，使用标准化协议在全球范围内发送实时、按需、低成本和可跟踪的支付。

涟漪的历史

Ripple 于 2012 年由杰德·麦卡勒和克里斯·拉森(电子贷款的联合创始人)创立。但是齿轮早在 2004 年就开始转动了，比比特币早了四年，当时一位加拿大程序员 Ryan Fugger 开发了 RipplePay。

RipplePay 虽然不是基于区块链，但却是一个金融网络的安全支付系统。2012 年，杰德·麦卡勒和克里斯·拉森创办了 OpenCoin 公司，2013 年更名为 Ripple Labs。

Ripple 以不同的方式处理这个问题。它的目的不是取代银行系统。相反，它的目标是通过提供一种分散的方式，以最低的交易费用进行快速支付，从而为传统系统提供一种替代方案。

Ripple Labs 在 2012 年创建了 Ripple transaction protocol (RTXP ),用于低成本的跨境快速资金转移。该公司开发了两种主要的银行间快速转账产品 xRapid 和 xVia。

xRapid 使用 XRP 进行价值交换，而 xVia 不需要它。这两者过去都是在 xCurrent 上运行的。在 2019 ，该公司合并了 xCurrent 和 xVia，并将其更名为 RippleNet，而 xRapid 则更名为“按需流动性”

Ripple Network

Source

什么是 XRP？

XRP 是 2013 年 1 月为 Ripple 网络设计的本地加密货币。它的创建主要是为了在参与方之间转移价值，而不是存储价值。

这种加密货币的最小单位是百万分之一 XRP 或一滴。

xrp 没有被开采——这里没有工作证据或利害关系证据。事实上，所有的 xrp，总共 1000 亿个，都是在一开始就被创造出来的，而且大部分都没有在流通。大约 600 亿 xrp 由该公司自己持有，这使得一些投资者对投资该公司持谨慎态度。

为了减轻这些担忧，该公司在 2017 年将 550 亿 xrp 放入加密安全的托管账户。这些资金被锁定在 55 个独立的托管账户中，每个账户 10 亿美元，从 2017 年底开始，每个月的第一天到期。

一旦发布，这些 xrp 就可供公司用于资助业务相关的运营、向投资者销售以及激励客户。任何未使用的 xrp 将被放回托管。

Comparison of transaction settlement time

Source

传统上，标准银行和其他金融机构使用美元将一种法定货币兑换成另一种法定货币，这导致了国际交易的延迟。Ripple 使用 XRP 而不是美元进行货币兑换。

所以不需要交换费，从而大大降低了交易成本。此外，交易只需几秒钟即可完成，而不是几小时或几天。

银行使用 XRP 为资金转账即时获取流动性，从而加快交易处理速度。

虽然 XRP 是为 RippleNet 设计的，但它可以脱离公司独立存在。为了澄清关于瑞波和 XRP 的常见神话，请查看福布斯的这篇文章。

Price and Volume charts for XRP

Price and Volume charts for XRP: Source

波纹的特征

RippleNet

RippleNet 是一个支付服务商网络，为全球各种金融机构提供连接。它使交易快速、高效、便宜。RippleNet 提供了一个分散的结构、现代化的双向信息传递和流动性解决方案。

假设你想从日本转一些钱到尼日利亚。如果我们以传统的方式行事，日本的银行不太可能拥有尼日利亚奈拉(NGN)的储备。正如你所想象的，在这个设置中涉及到各种各样的银行和支付提供商，它们都有自己的一套规则。

RippleNet 旨在通过提供一组称为 Ripple Transaction Protocol (RTXP)的规则，为整个互联网的价值转移提供一个框架，该协议为网络的所有参与者建立了共同的规则。

这消除了交易处理中的瓶颈，并使网络参与者更容易彼此密切合作。你可以把它想象成类似于 HTTP，它是一种在互联网上传输信息的通用协议。

RippleNet Capabilities

Source

共识和验证

独立的验证器节点通过检查 XRP 事务是否遵循 RTXP 来就它们的顺序和有效性达成一致。Ripple 使用 Ripple 协议共识算法(RPCA)在验证器节点之间达成共识。

因为已经选择了验证器，并且所有 xrp 都已经存在，所以这里不涉及挖掘过程。所以没有时间、精力或金钱花在采矿上。

分类账每隔 3-5 秒就未结交易达成共识，分类账更新。

通过运行验证程序，任何人都可以成为验证者。验证者被激励维护分类账，仅仅是为了从使用系统中获益。

网络上有超过 150 个验证器，默认唯一节点列表上有大约 36 个——Ripple 运行其中的 6 个节点。

你可以在白皮书的中了解更多关于共识协议的信息。

Consensus in Ripple

Consensus in Ripple: Source

唯一节点列表

唯一节点列表(UNL)是网络参与者信任的节点列表。任何人都可以通过运行程序成为验证者。因此，谨慎地向 UNL 添加节点至关重要。

目前，三家出版商(Ripple、XRP 分类帐基金会和 Coil)根据他们过去的表现、经过验证的身份和负责任的 IT 政策发布了推荐验证者的默认列表。这称为默认唯一节点列表(dUNL)。

然而，每个网络参与者可以选择并添加他们自己的一组验证器到 UNL 中。

方法

想要加入 Ripple 网络的个人或实体可以接近网关。网关通常由银行运营。他们为网络之外的人提供了一个传播的入口。

网关在希望完成交易的双方之间的信任链中充当中介。网关帮助客户使用 Ripple 网络转移资金，包括传统货币和加密货币。

XRP 分类帐

XRP 货币的分布式分类帐记录了使用 XRP 完成的所有交易，这些交易都经过验证器的确认。它被称为 XRP 纪事报。

XRPL 由网络的独立参与者维护，每隔几秒更新一次。虽然 Ripple 是网络的贡献者，但其权利与其他贡献者的权利相同。付款是不可逆的，也没有退款。

XRP 分类账也适用于 XRP 以外的货币。

按需流动性

传统上，美元在全球金融交易中被用作储备货币。让我们回到以前的例子，从日本转移一些金额到尼日利亚。

如果我们以传统的方式行事，日本的银行不太可能拥有尼日利亚奈拉(NGN)的储备。但是全世界所有的银行都持有美元储备。

因此，首先，必须将日元(JPY)兑换成美元，然后在目的地国家将美元兑换成 NGN，以便进行转账。

XRP 旨在充当 Ripple 网络上不同支付提供商之间的过渡货币。

这些账户必须预先注入资金，以便快速地将资金从一种货币转移到另一种货币。但是，银行使用营运资金进行前期融资是有风险的。

XRP 通过信托额度提供按需流动性(ODL)，类似于有限的信贷额度。按需流动性是仅向合格的机构 RippleNet 客户提供的服务，不面向零售客户。

Diagrammatic representation of on-demand liquidity

Source

Ripple 是如何工作的？

从设计本身来看，Ripple 的工作方式不同于比特币和以太网等其他区块链加密货币。这个网络更加集中。

在这里，任何人都可以通过下载所需的软件成为账本持有者。然而，有少数可信验证系统批准交易。这些验证者通常为知名银行和机构所有，信任主要建立在他们的声誉上。

只有在大多数验证者同意的情况下，任何交易才会被批准。

每次在网络上进行新的交易时，验证器都会对其进行验证，并在几秒钟内更新分类账。该软件确保分类账一致，如果不一致，交易将暂停，直到差异得到解决。

交易可以在几秒钟内完成，交易费用很低。目前，该网络每秒处理多达 155 笔交易，平均费用为 0.0002 美元。相比之下，比特币网络需要大约 10 分钟来确认交易，费用高达 25 美元。

值得注意的是，整个过程对最终用户是透明的。对最终用户来说，这似乎只是一个简单的实时转账问题。

How Ripple works

Source

在 RippleNet 上，交易主要通过两种媒介进行:通过 XRP 或借据。当一家银行向另一家银行转账时，他们有两种选择:向 XRP 支付货币兑换费或写借据。

如果交易通过 XRP 结算，交易就完成了，因为 XRP 是可交易的资产。

然而，如果银行宁愿保持开放的标签，他们可能会发出借据。借据(我欠你的)类似于债务票据。这不是你拥有的东西，而是你欠的东西。

当然，如果你接受某人的借条，你需要相信他们会还你钱。这就是信任线发挥作用的地方。

在 RippleNet 上，trustline 类似于信用额度，就像是一份在一定额度内信任某人的协议。借据是不可互换的，但是你可以用借据交换几乎任何资产。

与借据不同，XRP 没有交易对手风险。那么为什么会有人想用借条进行交易呢？这是因为，像其他加密货币一样，XRP 也是不稳定的，因此它尚未获得普遍接受。因此，一些机构宁愿远离 XRP。

纹波的优势

Ripple 提供了许多优于传统支付系统的优势。

  • 与传统系统相比，Ripple 使全球支付变得快速、高效和透明。XRP 作为一种流动性工具，使得整个过程无缝衔接。
  • 涟漪交易比其他加密货币更快。与比特币和以太坊在几分钟内结算交易相比，XRP 交易需要 3-5 秒。
  • Ripple 提供了改进的可扩展性。XRP 每秒 24x7 不间断地处理 1，500 笔交易，并且可以扩展到与 Visa 相同的吞吐量。
  • Ripple 的跨货币支付系统吸引了许多金融机构和银行加入其网络。
  • 区块链网络为不同的成员建立了一个无信任的环境，使他们紧密而有效地合作。
  • Ripple 旨在迎合大型银行和金融机构。因此，它的解决方案是根据他们的需求量身定制的，这推动了它在这些公司中的受欢迎程度。
  • 许多主要金融机构信任并正在使用 Ripple。这让它更值得信赖。
  • 没有通货膨胀是可能的，因为所有的 XRP 都已经被创造出来了。

Some of the financial institutions using RippleNet

Some of the financial institutions using RippleNet: Source

波纹的缺点

现在让我们来看看 Ripple 的缺点。

  • Ripple 的设计主要是为了吸引金融市场中的大玩家。因此，对于零售用户来说，它的用途有限。
  • RippleNet 不像公共区块链那样是一个完全分散的网络。
  • 大多数 xrp 由 Ripple 公司自己持有。这意味着公司可以控制网络的运作。
  • 有人担心，如果该公司想出售 xrp 的库存，可能会导致市场供过于求，导致价格暴跌。联合创始人之一杰德·麦卡勒(Jed McCaleb)于 2014 年离开 Ripple，拥有约 47 亿 XRP。他已经在无数次事件中抛售大量此类股票，进一步加剧了这种担忧。

Ripple 和比特币、以太坊有什么不同？

|

Ripple

|

Bitcoin and Ethereum

|
| 它专注于更大的金融机构和支付提供商 | 它专注于个人，并寻求脱离中央金融机构 |
| 这个网络可以用来转移任何商品或货币，而不仅仅是 XRP | 使用本地加密货币进行交易 |
| 迎合快速和廉价的全球交易 | 较高的交易成本和低的交易速度 |
| 可攀登的 | 可扩展性仍然是一个挑战 |
| 半许可的区块链 | 公共区块链 |
| 分散程度较低 | 更加分散化 |
| xrp 没有被开采，所以只有有限的数量在流通 | 它们被开采出来，所以流通中的硬币数量不断增加 |
| 使用 RPCA(波纹协议共识算法)进行共识 | 使用工作证明或利益证明来达成共识 |
| 可忽略的能源消耗 | 巨大的能源消耗 |
| 运行验证程序需要最少的计算机资源 | 成为验证者/挖掘者需要大量的金钱/计算资源 |

新闻中的涟漪

Ripple 因其各种违法行为而不断出现在新闻中。

第一个法律问题发生在 2015 年，当时公司因在没有适当注册的情况下销售 XRP 代币而违反了银行保密法，被罚款 70 万美元。此后，Ripple 为未来的 XRP 投资者介绍了《了解你的客户》( KYC)。

2020 年 12 月，美国证券交易委员会(SEC)对 Ripple Labs 首席执行官布拉德·加林豪斯和联合创始人克里斯·拉森提起诉讼。诉讼声称，Ripple 单独控制加密货币的基础设施，因此 XRP 是一种需要在 SEC 注册的证券。

它还声称，Ripple 严重依赖其在 XRP 的销售来为其运营提供资金。Ripple Labs 坚持认为 XRP 是一种加密货币，而不是一种证券。

这场官司影响了 XRP 的价格和接受度。毫无疑问，整个加密社区都在以极大的兴趣关注着它。

结论

在这篇博客中，我们讲述了 Ripple 的历史，探讨了 Ripple 和 XRP 是什么，Ripple 的功能和工作方式，它的优缺点，以及它与两种主要加密货币比特币和以太网的区别。我们也看了为什么 Ripple 最近出现在新闻中。

从区块链到重新定义金融科技的三大加密货币(比特币、以太网和 XRP)，我们在这一系列博客中涉及了很多内容。

我希望这些博客已经帮助您更多地了解了它们背后的技术、主要加密货币的优缺点以及它们的异同。

如果你也想进入 Ripple 和其他加密货币的世界，请查看 Quantra 的这个关于加密交易策略的中级课程。在这里，你将了解加密货币，涉及的风险，如何加密交易，并在 Python 中创建了 3 种不同的当天交易策略-所有这一切只需 2.5 小时！现在就去看看吧！

免责声明:本文中关于加密货币的任何信息仅用于传达一般信息。本文不提供投资、法律、税务等。建议。您不应将本文中的任何信息视为就加密货币使用、法律事务、投资、税收、加密货币开采、交易所使用、钱包使用等做出任何特定决定的呼吁。我们强烈建议向您自己的财务、投资、税务或法律顾问寻求建议。QuantInsti 和本文作者均不对因依赖本文发布或链接的信息而导致的任何损失、损害或不便承担责任。

HFT 一家顶级公司的风险分析师——斯里尼瓦斯分享了他的故事

原文：https://blog.quantinsti.com/risk-analyst-top-hft-firm-srinivas-shares-story/

好奇心常常迫使一个人去探索更多，找到问题的答案和解决方案，从而使一个人获得想要的信息。有了正确的技能和知识，一个人可以实现他的梦想，并可以在自己选择的任何领域获得专业知识。

Srinivas Hosur

Srinivas Hosur 先生是 iRageCapital 的合规和风险分析师，他通过不断的决心和专注来学习和提升他在交易领域的知识，从而实现了在 HFT 公司工作的梦想。

让我们看看斯里尼瓦斯对他的旅程是怎么说的吧！

  • Hi Sri Niwas, tell us something about yourself?

我来自印度的海德拉巴。我已经完成了我的金融工商管理硕士学位，我的第一份工作是在一家贸易公司。那是我接触人工交易和算法交易的地方。我是一个非常好奇的人。我喜欢在各种主题上提高自己的知识。

  • As an algorithm trader, what prompted you to choose EPAT to further explore this field?

我没有使用 MS Excel 或任何其他统计或编程语言的经验。但是我很快就感觉到了手工交易的局限性，开始阅读关于系统化和自动化交易的书籍。Excel 有其局限性，我很快感到有必要转向一种统计语言。

但是我手头只有很少的项目来试验我从书本和网络上学到的东西。我想学习算法交易者应该具备的所有相关技能。我开始在网上搜索课程，那时我开始了解 EPAT。它涵盖了我正在寻找的大部分东西。

  • How do you get along with EPAT?

我发现 EPAT 课程非常详尽，正是我一直在寻找的东西。它涵盖了很多主题，节奏很快，讲座和笔记都设计得很好。我将永远感谢 EPAT 的一件事是，我接触到了机器学习。在四个月的时间里，我学到了大部分东西，关于流行的行业方法、数学模型、编码、回溯测试、使用各种统计和编程工具等知识。我能够应用一些数学模型来建立动量，均值回复等。策略。

  • How did EPAT help you achieve your goals?

加入 EPAT 的原因之一是希望加入一家 HFT 公司。正是因为 EPAT，我才能在 HFT 的一家公司找到工作。我绝对想不出别的办法来实现这一点。

  • How did you apply the concepts you learned in EPAT to trading?

在 EPAT 之后，我的工作方式变得更加精致和高效。Python 中面向对象的编码部分是我在学会这些技术后经常使用的东西之一，它对我的日常工作很有帮助。成功应用机器学习技术并建立一个策略是我近期的目标。

  • What information do you want to give to aspiring quantitative/algorithmic traders?

设法跟上交易行业发展的步伐，只有在这之后你的工作才会有意义。在那之前，你做的任何事都已经被很多人做过了。在这场零和游戏中，有优势的总是赢家。获得优势的唯一方法是创新，成为先行者。

斯里尼瓦斯的旅程树立了一个榜样，告诉我们如何通过毅力和对知识的渴求来实现最终目标。

你也可以通过 EPAT 提升你的算法交易知识，它可以确保你具备必要的知识，并提高你的算法交易技能。EPAT 是一门综合课程，涵盖的主题从统计学&计量经济学到金融计算&技术，包括机器学习 更有 。

免责声明:为了帮助那些正在考虑从事算法和量化交易的人，本案例研究是根据 quantin STI EPAT 项目的学生或校友的个人经历整理的。案例研究仅用于说明目的，并不意味着用于投资目的。EPAT 项目完成后取得的结果对所有人来说可能并不一致。

如何成为一名风险分析师？

原文：https://blog.quantinsti.com/risk-analyst/

由查尼卡·塔卡

成为一名成功的风险分析师无疑需要你拥有良好的教育背景，但除此之外，在这份工作中，你还需要很多个性特征、技能和兴趣。有了合适的技能，你可以获得许多风险分析师的工作。

因此，在这篇文章中，你将学到成为一名风险分析师并使其成为成功职业的所有重要因素。

本文涵盖:

谁是风险分析师？

风险分析师是识别、评估和监控组织所面临风险的人。风险分析师的角色要求他们在分析历史数据的帮助下找出风险的影响。

风险分析师专门研究风险的类型。最常见和已知的风险类型是信用风险、流动性风险、市场风险和运营风险。

此外，我们将了解风险分析师的职责或工作描述。

风险分析师做什么？

风险分析师负责投资的风险管理，以帮助他们工作的组织取得财务成功。

风险分析师主要识别和分析与上述领域相关的潜在风险，然后制定相应的风险缓解策略。此外，这些策略有助于最大化收益，同时降低风险。

风险分析师的职责是:

  • 审阅财务及会计相关文件或文件
  • 查看与行业相关的发展和其他资源
  • 调查和研究当前场景中的事件，并预测对经济和金融业的任何影响
  • 不断检查合规性要求
  • 为紧急情况创建应急计划，如由于疫情局势或政府政策变化等导致的市场崩溃。
  • 规避风险

接下来，我们将了解风险分析师的类型。

风险分析师的类型

风险分析师工作主要是交易、金融服务和私人银行等领域需要的工作。有四种主要类型的风险分析师:

  • 信用风险分析师
  • 市场风险分析师
  • 运营风险分析师
  • 监管风险分析师

信用风险分析师

信用风险分析师分析组织所面临的风险，因为其客户或顾客拖欠贷款、信贷以及不支付商品或服务的款项。

信用风险分析师这一职位的薪水在 29，624.75 美元到 37，919.68 美元之间。此外，在决定信用风险分析师的薪酬时，职位的资历也至关重要。

这个角色对于投资银行和投资公司来说极其重要。投资银行部门的信用风险分析师帮助找出在购买诸如奇异期权之类的产品时该信任哪家机构。因此，信用风险分析师有助于防范此类交易对手风险。

市场风险分析师

市场风险专家对给公司股价带来风险的因素(如经济衰退)的负面影响进行分析。

市场风险分析师的工资从 109，234 美元到 115，800 美元不等。市场风险分析师主要受雇于对冲基金，在那里他们帮助风险经理进行市场风险测量、模型和最佳实践。

除了对冲基金，他们还有机会受雇于所有金融机构，包括但不限于生产和销售能源的能源行业。因此，市场风险分析师在确保正确调查市场风险以便采取预防措施方面发挥着至关重要的作用。

运营风险分析师

运营风险分析师帮助分析风险运营情况或事件的影响，如员工欺诈、材料浪费、产品故障和系统故障等。运营风险分析师的工资从 5001.86 美元到 23184.31 美元不等。

考虑到每家公司都要承担一定的运营风险，因此以尽可能好的方式管理这种风险至关重要。例如，缺乏应对疫情、经济衰退等情况的应急计划。交易时会导致亏损。运营风险分析师会帮助您制定针对此类紧急情况的计划。

监管风险分析师

这位分析师找出已经到来的立法的影响，以及任何可能对组织产生影响的即将到来的立法的影响。监管风险分析师的平均工资从 44，000 美元到 89，000 美元不等。

几乎所有行业都会聘请监管风险分析师，但具体来说，是那些涉及技术、金融、会计、政府服务和运营的公司。

这类公司的经营主要受立法变化的影响。例如，税收变化以及政府的新规定影响了股票市场的交易方式。

好吧！这都是关于风险分析师的类型。这里同样重要的是要注意，风险分析师身兼数职，而且确实单枪匹马地扮演着不同的角色。因此，一家公司可以雇佣你作为风险分析师来履行这些职责。

注:上述所有工资均为 Glassdoor 网站上以美元为单位的平均范围。

成为风险分析师的教育

要成为风险分析师，有一些学位和课程可以帮助你掌握正确的知识。

风险分析师的初级职位通常要求:

  • 大专文凭或
  • 大学本科学位

风险分析师的高级职位可能需要:

  • 研究生学位
  • 博士/博士生

风险分析师的学术背景/领域:

  • 数学
  • 工程
  • 金融
  • 保险统计计算科学
  • 风险管理
  • 数学金融
  • 信息系统
  • 统计数字
  • 企业管理
  • 数学金融
  • 基础科学

雇主可能更喜欢风险分析师候选人拥有以下一个或多个证书:

  • 风险管理助理(ARM)
  • 特许金融分析师
  • 金融风险经理(FRM)
  • 专业风险经理(PRM)

成为风险分析师的必备特质

成为风险分析师需要具备以下特征:

  • 分析能力强，精通数学
  • 数据分析知识
  • 降低风险的战略思维
  • 积极进取的态度
  • 协调技能，了解不同部门关于风险的要求
  • 高度道德

除了上面提到的风险分析师的特征之外，一个人必须确保他完全享受这份工作，并且有奉献精神和毅力。这种坚定的态度使个人享有持久和成功的职业生涯。

风险分析师通常是全职聘用的，但也可以由一些公司以合同形式聘用。他们的作用是非常关键的，以确保公司通过控制共同风险最大化其收益。

风险分析师工作所需的技能

到目前为止，我们已经看到一个风险分析师在不同的行业从事特定的风险控制工作。要获得一份风险分析师的工作，必须注意以下几个方面:

  • 变得熟练
  • 寻找合适的职业机会
  • 准备面试
  • 持续的专业发展

变得熟练

要想获得风险分析师的工作，填补技能缺口是极其重要的，即使你有自己喜欢的教育学位。在个人层面和学术层面，你都可以在申请风险分析师工作之前建立这些要求。

寻找合适的职业机会

作为一名有抱负的风险分析师，你必须列出你感兴趣的顶级公司，然后申请最适合你的职位。

准备面试

通过使用 LinkedIn 等平台，你可以通过展示你的技能和才华来帮助自己获得面试机会。获得几次面试的经验也能帮助你为更好的机会做好准备。

持续的专业发展

跟上新的机遇，找到在职业上提升自己的方法，这将有助于你提升自己的能力。此外，你将能够为你工作的公司做出杰出的贡献。主要是，即使找到了工作，你也必须不断提升自己。

雇佣风险分析师的公司类型

让我们看看哪些公司需要风险分析师积极工作，它们是:

  • 商业银行
  • 贸易公司
  • 投资银行
  • 金融服务机构
  • 风险管理咨询公司
  • 保险公司

雇佣风险分析师的顶级公司包括:

此外，风险分析师不限于一个部门，这意味着他们受雇于属于公共和私营部门的不同公司。

风险分析师工资

尽管风险分析师的工资水平因各种因素而异，如经验、能力、雇主规模等。，我们在这里提到的每个国家的风险分析师都有一个平均基本工资:

|
国家 |
平均基本工资/年 |
美元($) |
|
美国 |
$61,833 |
$61,833.00 |
|
印度 |
56 万卢比 |
$7,552.00 |
|
英国 |
£35,018 |
$46053.05 |
|
加拿大 |
大约 66，000 美元 |
$50482.74 |
|
新加坡 |
65000 新元 |
$48221.88 |
|
香港 |
2 万港元 |
$2579.66 |

来源:玻璃门

结论

风险分析师的角色需要一些奉献精神和毅力，这与你对文章中提到的特定职责的兴趣是一致的。

拥有一套好的技能对于成功面试和保持未来的声誉至关重要。作为一名风险分析师，你会被一些进步的公司聘用，并有机会在专业和财务上获得发展。

如果你正在寻找一次量化面试，请查看 Quantra 提供的免费量化面试准备课程，它为你提供了合适的面试问题组合来练习和提高你的知识和技能。立即注册！

免责声明:本文提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害负责。所有信息均按原样提供。

改变风险管理的观念

原文：https://blog.quantinsti.com/risk-management-current-markets-webinar/

https://www.youtube.com/embed/uzAhV94UiF8?rel=0

2015 年 7 月 23 日邀请函:

日期-2015 年 8 月 10 日

时间–IST 时间晚上 6:00/新加坡时间晚上 8:30

算法交易系统的风险管理，近期失败案例研究

金融市场中自动化交易的增加已经完全改变了风险的概念——对风险经理、交易经理和交易员都是如此。除了管理市场、金融、信用和流动性风险之外，专业人士现在还需要了解系统和操作风险。

在演讲中，将讨论算法交易中的几个主要风险监管问题。

算法交易的重大风险监管问题

  • 骑士资本是如何在 45 分钟内损失 4.6 亿美元的？
  • 德意志银行为什么被迫关闭他们在东京的算法交易部门？
  • Infinium Capital 在交易原油 ETF 时出了什么问题，为什么被罚款 85 万美元？
  • 是什么失误导致韩国 HanMag 证券在几分钟内亏损 570 亿韩元？

还有几个…

在第二部分，将从以下角度广泛讨论管理特定于算法交易的风险情况的方法。

管理风险情况的方法

  • 接近
  • 一致性
  • 质量
  • 算法
  • 技术
  • 可量测性

在最后一部分，将讨论量化策略交易算法的监管风险管理要求。

演讲者

Rajib Ranjan Borah

拉吉布·兰詹·博拉

Rajib is the co-Founder & Director of iRageCapital and QuantInsti High Frequency Trading Systems for South East Asian markets helping generate significant volumes within the options segment. At QI,Rajib manages the course segment on option derivatives; and also works with exchanges, financial & educational institutions to design educational programs. He has conducted workshops and conferences in America, Europe and Asia

风险管理:最大化长期增长

原文：https://blog.quantinsti.com/risk-management-webinar-25-october-2018/

https://www.youtube.com/embed/kt1jSw9BDt0?rel=0

2018 年 10 月 25 日星期四 IST 时间下午 6:30 |格林威治时间下午 13:00 |格林尼治时间晚上 9:00

会议大纲

风险管理是系统交易中最容易被忽视但又非常重要的方面。在本次网络研讨会中，您将学习风险管理技术，以克服最常见的挑战。本课程将向你解释最佳杠杆、对冲和风险指标的概念。

  • 风险管理和真正的挑战
  • 最佳杠杆:凯利公式，最大下降
  • 市场风险:止损、波动目标、风险价值
  • 对冲技术
  • 风险指标

演示文稿

您可以点击此处查看本次网络研讨会的 powerpoint 演示文稿:

//www.slideshare.net/slideshow/embed_code/key/zgHApx33zUxziJ

Risk Management: Maximising Long-Term Growth Presentation from QuantInsti

Python 代码

您可以从这里下载网上研讨会中展示的 python 代码:

演讲者

Marco nicolás Dibo(Quanticko Trading 首席执行官)

marco

Marco 的职业生涯是作为交易员和投资组合经理度过的，他特别关注股票和衍生品市场。

他专门研究量化金融和算法交易，目前担任阿根廷 Valores S.A .的量化交易部门主管。Marco 还是 Quanticko Trading S.A .的联合创始人兼首席执行官，quanti cko Trading s . a .是一家致力于开发高频交易策略和交易软件的公司。Marco 拥有圣安德烈斯大学的经济学学士学位和金融学硕士学位。Marco 是 EPAT 的成功校友，并在课程中撰写了一个关于配对交易策略和使用 Quantstrat 进行回溯测试的项目。

RNN、LSTM 和 GRU 进行交易

原文：https://blog.quantinsti.com/rnn-lstm-gru-trading/

由 Umesh Palai

在我之前的文章中，我们已经开发了一个简单的人工神经网络，并预测了股票价格。但是，在本文中，我们将利用 RNN(递归神经网络)、LSTM(短期记忆网络)&、GRU(门控递归单元网络)的力量来预测股票价格。

我们将使用 python 中的 TensorFlow 1.12 来编码这个策略。您可以从我的 GitHub 账户中访问所有 python 代码和数据集。

如果你还没有浏览过我之前的文章，我建议你在开始这个项目之前浏览一下。

如果你是机器学习和神经网络的新手，我会推荐你先去了解一下机器学习、深度学习、人工神经网络、RNN(递归神经网络)、LSTM(短时记忆网络)& GRU(门控递归单元网络)等的一些基本知识。

Machine Learning in Trading

涵盖主题:

编码策略

我们将从导入所有库开始。请注意，如果下面的库还没有安装，您需要在导入之前首先在 anaconda 提示符下安装，否则您的 python 将抛出一个错误消息

我假设你知道我们在这里使用的所有上述 python 库。

导入数据集

在该模型中，我们将使用 1996 年 1 月 1 日至 2018 年 9 月 30 日期间在 NSE 上交易的“RELIANCE”股票的每日 OHLC 数据。

我们导入数据集。名为“RELIANCE”的 CSV 文件。“NS.csv”保存在您计算机的个人驱动器中。这是使用 pandas 库完成的，数据存储在名为 dataset 的数据帧中。

然后，我们使用 dropna() 函数删除数据集中缺失的值。我们仅从该数据集中选择 OHLC 数据，该数据集中还包含日期、调整后收盘和成交量数据。

Importing Dataset

缩放数据

在分割数据集之前，我们必须标准化数据集。此过程会使所有输入要素的平均值等于零，并将它们的方差转换为 1。这确保了在训练模型时不会因为所有输入要素的不同比例而产生偏差。

如果不这样做，神经网络可能会混淆，并给予那些平均值比其他特征高的特征更高的权重。此外，网络神经元(如 tanh 或 sigmoid)的最常见激活函数分别定义在[-1，1]或[0，1]区间上。

如今，校正线性单位 (ReLU)激活是常用的激活，其在可能激活值的轴上是无界的。但是，我们将调整投入和目标。

我们将使用 sklearn 的 MinMaxScaler 进行缩放。

Scaling data

拆分数据集并构建 X & Y

接下来，我们将整个数据集分为训练数据、有效数据和测试数据。然后我们可以建立 X & Y，所以我们会得到 x_train，y_train，x_valid，y_valid，x_test & y_test。这是至关重要的一部分。

请记住我们不是像之前的项目那样简单地对数据集进行切片。这里我们给定序列长度为 20。

Splitting the dataset

我们的总数据集是 5640。所以前 19 个数据点是 x_train。接下来的 4497 个数据点是 y_train，其中最后 19 个数据点是 x_valid。接下来的 562 个数据点是 y_valid，其中最后 19 个数据点是 x_test。

最后，下一个和最后一个 562 个数据点是 y_test。我试着画这个只是为了让你明白。

Data points

建立模型

我们将建立四个不同的模型——基本 RNN 单元、基本 LSTM 单元、带窥视孔连接的 LSTM 单元和 GRU 单元。请记住，您一次只能运行一个模型。我把所有东西都放进一个编码里。

每当运行一个模型时，确保将另一个模型作为注释，否则结果将是错误的，python 可能会抛出错误。

参数，占位符&变量

我们将首先确定用于构建任何模型的参数、占位符和变量。人工神经网络从占位符开始。

为了适合我们的模型，我们需要两个占位符:X 包含网络的输入(T = t 时股票(OHLC)的特征), Y 包含网络的输出(T+1 时股票的价格)。

占位符的形状对应于 None，n_inputs，其中[None]表示输入是二维矩阵，输出是一维向量。

理解神经网络需要哪些输入和输出维度以正确设计它是至关重要的。我们将可变批量大小定义为 50，它控制每个训练批次的观察次数。

当 epoch 达到 100 时，我们停止训练网络，因为我们已经在参数中将 epoch 指定为 100。

Parameters Placeholders Variables

设计网络架构

在我们继续之前，我们必须为任何模型编写运行下一批的函数。然后，我们将分别为每个模型编写层。

Designing the network architecture

请记住，无论何时运行一个特定的模型，您都需要将其他模型作为注释。在这里，我们只运行 RNN 基础，所以我把所有其他的作为一个注释。你可以运行一个又一个模型。

RNN basic

成本函数

我们使用成本函数来优化模型。成本函数用于生成网络预测和实际观察到的训练目标之间的偏差度量。

对于回归问题，常用的是均方误差(MSE) 函数。MSE 计算预测值和目标值之间的均方差。

Cost function

优化器

优化器负责必要的计算，这些计算用于在训练期间适应网络的权重和偏差变量。这些计算调用梯度的计算，该梯度指示在训练期间权重和偏差必须改变的方向，以便最小化网络的成本函数。

开发稳定和快速的优化器是神经网络和深度学习研究的一个主要领域。

Optimizer

在这个模型中，我们使用 Adam (自适应矩估计)优化器，它是随机梯度下降的扩展，是深度学习开发中的默认优化器之一。

拟合神经网络模型&预测

现在，我们需要使我们创建的模型适合我们的训练数据集。在定义了网络的占位符、变量、初始化器、成本函数和优化器之后，需要训练模型。通常，这是通过小批量训练来完成的。

在小批量训练期间，从训练数据中抽取 n = batch_size 的随机数据样本，并输入到网络中。训练数据集被分成 n / batch_size 个批次，这些批次被顺序输入到网络中。此时，占位符 X 和 Y 开始发挥作用。它们存储输入和目标数据，并将它们作为输入和目标呈现给网络。

X 的一个采样数据批次流经网络，直到它到达输出层。在那里， TensorFlow 将模型的预测与当前批次中实际观察到的目标 Y 进行比较。

之后，TensorFlow 执行优化步骤并更新网络参数，对应于所选的学习方案。更新重量和偏差后，对下一批进行采样，重复该过程。该过程继续进行，直到所有批次都被呈现给网络。

所有批次的一次完整扫描称为一个时期。一旦达到最大次数或者用户定义的另一个停止标准适用，网络的训练就停止。

当 epoch 达到 100 时，我们停止训练网络，因为我们已经在参数中将 epoch 指定为 100。

Fitting the neural network model & prediction

现在我们已经预测了股票价格，并保存为 y_test_pred。我们可以将这些预测的股价与我们的目标股价进行比较，也就是 y_test。

为了检查输出的数量，我运行了下面的代码及其 562，它与 y_test 数据相匹配。

Y_test code

y_test output

让我们比较一下我们的目标和预测。我将目标(y_test)和预测(y_test_pred)收盘价放在一个名为“comp”的数据框架中。

现在我把两个价格放在一个图中，让我们看看它看起来怎么样。

Plotting the graph

Plotting output

现在我们可以看到，结果还不错。预测值与目标值完全相同，并与我们预期的方向一致。你可以检查这两者之间的差异，并以各种方式比较结果&在建立交易策略之前优化模型。

LSTM

现在我们可以运行基本的 LSTM 模型，看看结果。

LSTM

LSTM output

带窥视孔的 LSTM

让我们运行 LSTM 与窥视孔连接模型，看看结果。

LSTM peephole

peephole output

GRU

让我们运行 GRU 模型，看看结果。

GRU

GRU output

你可以用各种方式检查和比较结果&在建立交易策略之前优化模型。

结论

这个项目的目标是让你了解如何建立一个不同的神经网络模型，像 RNN，LSTM 和 GRU 在 python 张量流和预测股票价格。

你可以通过各种方式优化这个模型，建立自己的交易策略，考虑命中率、下降等因素，获得良好的策略回报。另一个重要因素是，我们在这个模型中使用了每日价格，所以数据点实际上很少，只有 5，640 个数据点。

我的建议是，在建立人工神经网络或任何其他最有效的深度学习模型时，使用超过 100，000 个数据点(使用分钟或分笔成交点数据)来训练模型。

现在你可以利用机器的能力和智能来建立自己的交易策略。

免责声明:本文提供的所有数据和信息仅供参考。QuantInsti 对本文中任何信息的准确性、完整性、现时性、适用性或有效性不做任何陈述，也不对这些信息中的任何错误、遗漏或延迟或因其显示或使用而导致的任何损失、伤害或损害负责。所有信息均按原样提供。

zip 存档中的文件列表:

  1. 深度学习 GRU LSTM RNN
  2. 信赖。纳秒

RSI 指标:股票、公式、计算和策略

原文：https://blog.quantinsti.com/rsi-indicator/

以重香重香

相对强弱指数(RSI)指标，顾名思义，告诉我们资产的相对强弱。换句话说，RSI 告诉我们股票相对于自身的表现如何。RSI 被认为是一个强大的技术指标，可以用来分析市场，也是交易者武器库的重要组成部分，因为它可以帮助他们在选择市场时机时做出更好的决定。当然，像其他指标一样，使用多个指标总是明智的，因为这有助于我们避免局限和过度依赖一个指标。

因此，在这篇博客中，除了理解 RSI 指标，我们还将看看它的局限性以及何时使用它们。我们将在这篇博客文章中讨论以下几点:

If you already know how to find the RSI indicator values, jump to the RSI based strategies here.

借助示例进行 RSI 计算

Let’s understand how to calculate and graph the RSI indicator now. While you can easily calculate the RSI indicator value with the python code, for explanation purposes we will do it manually.

| 日期 | Close(1) | Change(2) | Gain(3) | Loss(4) | Avg Gain(5) | Avg Loss(6) | RS(7) | 14-day RSI(8) |
| 24-04 | Two hundred and eighty-three point four six | | | | | | | |
| 25-04 | Two hundred and eighty point six nine | -2.77 | Zero | Two point seven seven | | | | |
| 26-04 | Two hundred and eighty-five point four eight | Four point seven nine | Four point seven nine | Zero | | | | |
| 27-04 | Two hundred and ninety-four point zero eight | Eight point six | Eight point six | Zero | | | | |
| 30-04 | Two hundred and ninety-three point nine | -0.18 | Zero | Zero point one eight | | | | |
| 01-05 | Two hundred and ninety-nine point nine two | Six point zero two | Six point zero two | Zero | | | | |
| 02-05 | Three hundred and one point one five | One point two three | One point two three | Zero | | | | |
| 03-05 | Two hundred and eighty-four point four five | -16.70 | Zero | Sixteen point seven | | | | |
| 04-05 | Two hundred and ninety-four point zero nine | Nine point six four | Nine point six four | Zero | | | | |
| 07-05 | Three hundred and two point seven seven | Eight point six eight | Eight point six eight | Zero | | | | |
| 08-05 | Three hundred and one point nine seven | -0.80 | Zero | Zero point eight | | | | |
| 09-05 | Three hundred and six point eight five | Four point eight eight | Four point eight eight | Zero | | | | |
| 10-05 | Three hundred and five point zero two | -1.83 | Zero | One point eight three | | | | |
| 11-05 | Three hundred and one point zero six | -3.96 | Zero | Three point nine six | | | | |
| 14-05 | Two hundred and ninety-one point nine seven | -9.09 | Zero | Nine point zero nine | Three point one three | Two point five two | One point two four | Fifty-five point three seven |
| 15-05 | Two hundred and eighty-four point one eight | -7.79 | Zero | Seven point seven nine | Two point nine one | Two point nine | One | Fifty point zero seven |
| 16-05 | Two hundred and eighty-six point four eight | Two point three | Two point three | Zero | Two point eight six | Two point six nine | One point zero six | Fifty-one point five five |
| 17-05 | Two hundred and eighty-four point five four | -1.94 | Zero | One point nine four | Two point six six | Two point six four | One point zero one | Fifty point two |
| 18-05 | Two hundred and seventy-six point eight two | -7.72 | Zero | Seven point seven two | Two point four seven | Three | Zero point eight two | Forty-five point one four |
| 21-05 | Two hundred and eighty-four point four nine | Seven point six seven | Seven point six seven | Zero | Two point eight four | Two point seven nine | One point zero two | Fifty point four eight |
| 22-05 | Two hundred and seventy-five point zero one | -9.48 | Zero | Nine point four eight | Two point six four | Three point two seven | Zero point eight one | Forty-four point six nine |
| 23-05 | Two hundred and seventy-nine point zero seven | Four point zero six | Four point zero six | Zero | Two point seven four | Three point zero three | Zero point nine | Forty-seven point four seven |
| 24-05 | Two hundred and seventy-seven point eight five | -1.22 | Zero | One point two two | Two point five four | Two point nine | Zero point eight eight | Forty-six point seven one |
| 25-05 | Two hundred and seventy-eight point eight five | One | One | Zero | Two point four three | Two point seven | Zero point nine | Forty-seven point four five |
| 29-05 | Two hundred and eighty-three point seven six | Four point nine one | Four point nine one | Zero | Two point six one | Two point five | One point zero four | Fifty-one point zero five |
| 30-05 | Two hundred and ninety-one point seven two | Seven point nine six | Seven point nine six | Zero | Two point nine nine | Two point three two | One point two nine | Fifty-six point two nine |
| 31-05 | Two hundred and eighty-four point seven three | -6.99 | Zero | Six point nine nine | Two point seven eight | Two point six six | One point zero five | Fifty-one point one two |
| 01-06 | Two hundred and ninety-one point eight two | Seven point zero nine | Seven point zero nine | Zero | Three point zero nine | Two point four seven | One point two five | Fifty-five point five eight |
| 04-06 | Two hundred and ninety-six point seven four | Four point nine two | Four point nine two | Zero | Three point two two | Two point two nine | One point four | Fifty-eight point four one |
| 05-06 | Two hundred and ninety-one point one three | -5.61 | Zero | Five point six one | Two point nine nine | Two point five three | One point one eight | Fifty-four point one seven |

第一步:收盘价

We will take the closing price of the stock for 30 days. The closing price is mentioned in column (1).

第二步:收盘价的变化

We then compare the closing price of the current day with the previous day’s closing price and note them down. Thus, from the table, for 25-04, we get the change in price as (280.69 - 283.46) = -2.77.

同样，对于 26-04，价格变化=(当前收盘价-前收盘价)= (285.48 - 280.6) = 4.79。然后，我们将在“变更(2)”一栏中列出结果。用这种方法，我们计算了价格的变化。

第三步:得失

We will now create two sections depending on the fact the price increased or decreased, with respect to the previous day’s closing price.

如果价格上涨，我们在“收益”栏中记下差额，如果是亏损，我们在“亏损”栏中记下差额。

例如，在 2004 年 6 月 26 日，价格上涨了 4.79 英镑。因此，该值将记录在“增益”栏中。

如果你看 25-04 年的数据，价格下降了 2.77。现在，虽然值在“变化”栏中写为负数，但我们没有提到“损失”栏中的负号。而且只写成 2.77。以这种方式，用于列“增益(3)”和“损耗(4)”的表格被更新。

第四步:平均得失

In the RSI indicator, to smoothen the price movement, we take an average of the gains (and losses) for a certain period.

虽然我们称之为平均值，但还是需要一点解释。对于前 14 个周期，它是值的简单平均值。

为了解释它，我们将查看平均增益栏。

因此，在该表中，前 14 个值将是从(25-04)到(14-05)，即(0.00+4.79+8.60+0.00+6.02+1.23+0.00+9.64+8.68+0.00+4.88+0.00+0.00+0.00)/14 = 3.13。

现在，由于我们更加强调最近的值，对于下一组值，我们使用下面的公式，

[(Previous avg. gain)*13)+ current gain)]/14.

因此，对于(15-05)，我们将计算平均增益为[(3.13*13)+0.00]/14 = 2.91。

同样，我们也将计算平均损失。

基于这些公式，该表针对“平均增益(5)”和“平均损耗(6)”列进行更新。

步骤 5:计算 RS

Now, to make matters simple, we add a column called “RS” which is simply, (Avg Gain)/(Avg Loss). Thus, for 14-05, RS = (Avg Gain)/(Avg Loss) = 3.13/2.52 = 1.24.

以这种方式，用于列“RS (7)”的表被更新。在下一步中，我们最终计算出 RSI 值。

步骤 RSI 的计算

RSI = [100 - (100/{1+ RS})].

For example, for (14-05),

RSI =[100-(100/{ 1+RS })]=[100-(100/{ 1+1.24 })]= 55.37。

以这种方式，表格被更新。

这是我们得到 RSI 值的方法。RSI 指标图总是根据收盘价创建的。例如，如果我们考虑上表中的 RSI 值，图表应该如下:

RSI Indicator example

虽然这里提到的 RSI 公式被普遍接受，但我们可以根据平均损益值的权重对公式进行某些修改。众所周知，随着数据点数量的增加，RSI 指标可以更好地衡量市场。在你开始做交易决定之前，某些来源推荐至少 250 个数据点。

RSI 指标受欢迎的原因之一是因为它的值总是在 0 到 100 之间。这使得阅读和形成关于资产的观点变得容易。此外，人们普遍认为，低于 30 的数值表明“超卖”，而高于 70 的数值表明“超买”。

然而，这并不像看起来那么简单，如果我们试图仅仅基于这个因素进入和退出市场，我们将无法有效地交易，因为在许多情况下，这个建议可能会失败。你可以在下图中看到，从 3 月 19 日到 4 月 25 日，收盘价甚至在进入超买区后还在继续上涨。

RSI Fail

记住这一点，让我们试着看看几个基于 RSI 指标的策略。

RSI 策略

作为趋势指标的 RSI

RSI works as a reference when you want to gauge if the market is going through a bullish or bearish trend. While the general assumption that an indicator above 70 indicates overbought and below 30 indicates oversold holds true for most of the cases, there are others who insist that it can be held true for values above 66.6 and below 33.3 as well.

如果 RSI 收盘高于 66.6，但低于该值，不应该认为趋势已经逆转，你应该立即做空股票。相反，我们寻找图表，只要它保持在 33.3 以上，我们就可以说市场仍然看涨资产。

你可以在下图中看到，RSI 指标在 2018 年 7 月越过超买区，从那以后，价格继续上涨，表明牛市。

RSI Trend Indicator

同样，如果 RSI 跌破 33.3，上涨但没有越过 66.6 关口(或假设的 70)，我们可以得出市场看跌的结论。

然而，人们不应将此作为购买(或出售)相关资产的唯一指标。我们将进入下一个话题来了解全貌。

RSI 作为支撑和阻力

As we have understood how to set up the RSI trend indicator, we can see that as the number of periods of gains increases when compared to the number of periods of losses, the RSI values will keep increasing. Thus, it gives a strong indication of a longer-term trend than the closing prices where the daily price fluctuations could show us a different story.

就像收盘价一样，我们可以使用 RSI 指标值来绘制支撑位和阻力位的趋势线，因此，在 RSI 值中可以很容易地观察到这一趋势的突破。你可以在下图中看到 RSI 和收盘价是如何突破的。

RSI Support and Resistance

这里的交易是正确识别突破是可持续很长一段时间，还是一个错误的信号。

相对强弱和背离

RSI indicator can also be used to predict a divergence in the trend before the price trend actually reverses.

例如，如果价格线正在走高，但 RSI 指标由于资产的相对强度与前一时期的增长相比有所减弱而下跌，则通常可以发现背离。

例如，让我们说，价格收盘高于前几天，但收益并不像同期的平均收益那样可观。然后，RSI 会以低于前一天的价格收盘。在这方面，我们可以得到一个信号，即市场将在几天后检查价格，并据此进行交易。你可以在下图中看到，RSI 呈下降趋势，而价格持续上涨。最终，收盘价也会下降。

RSI Divergence

同样的道理，当收盘价已经下跌了一段时间，但 RSI 开始走高，这意味着价格将回升。

RSI 双底信号和双顶信号

As we have discussed in the section on Bollinger Bands, we can identify the double bottom and double top pattern using the RSI indicator too. The gist of the double bottom pattern identification is as follows.

  1. RSI 指标收于 30 以下，之后上涨至 30 关口以上。
  2. 它再次向南，但收盘时高于 30，然后再次大幅上涨。

This is seen as a “W” formation on the chart. Traders usually use this pattern as a confirmation that the market is headed for the bullish direction. You can see in the following graph that the RSI indicator breached the 30 barriers on 2 Jan before rising up sharply and then closed below, but above the 30 barriers on 7 Jan. It then rose again and continued to rise throughout the month of January and February which indicates a bullish run. RSI Double Bottom

类似于双底，双顶的形态形成如下:

  1. RSI 指标突破 70 水平，然后再次跌破 70 水平。
  2. 它再次上升，但收盘低于 70，然后再次急剧下降。

This is seen as an “M” formation on the price chart. Traders usually use this pattern as a confirmation that the market is headed for the bearish direction. You can see in the graph given below, the RSI level breaches 70 on Dec '17. Later, it falls below the 70 thresholds and while it does rise higher, it does not cross the 70 thresholds again and then starts dropping, indicating a bearish run which lasts a year. RSI Double Top

RSI 和 MACD 策略

We have long understood that using a sole indicator as the basis for your trading decisions can be disastrous if we fail to read or there is a false signal generated by the indicator. The smart investor uses 2 or more indicators to identify a positive (or negative) signal and enters the market accordingly. With this factor, we use RSI and MACD to identify signals which can be used to trade profitably. To understand MACD and how to calculate it, you can refer to this article.

为什么我们一起使用 RSI 和 MACD 指标？

我们一起使用 RSI 和 MACD 的原因是，由于它们比较资产价格行为的固有性质，它们是互补的。

在这个策略中，当 RSI 和 MACD 都显示资产超卖时，我们进入交易，当任何一个指标给我们一个价格已经进入超买区的信号时，我们退出交易。

你可以在上面的图表中看到，MACD 越过中线下方，表明下降趋势，但我们会等到 2018 年 11 月 RSI 突破 70 关口，但随后急剧下降。这里，我们有两个指标可能告诉我们，市场正在走向熊市，毫无疑问，我们可以看到收盘价一直下降到 2018 年 11 月底。因此，我们可以在 11 月做空该股，因为我们看到 RSI 指标在再次上涨前跌破 30，我们可以退出该头寸。

相对强弱指标和 MACD 指标的差异

While we did mention that RSI indicators and MACD indicators have certain similarities, they have a different approach towards it. While RSI indicators consider the ratio of the gains and losses compared to the previous day, MACD is essentially a moving average of the price.

因此，我们应该小心，不要期望 RSI 和 MACD 会在特定的时间点给出相同的信号。

RSI 的局限性

  1. RSI 的基本属性表明 70 以上的水平超买，这在强牛市中可能被证明是错误的，在这种情况下，公司发展迅速，并向股东公布良好的回报。在这种情况下，RSI 可以长时间保持在 70 以上，这对卖空者来说是灾难性的。熊市也是类似的情况，RSI 可以保持在 30 以下，并且在很长一段时间内不会超过该水平。
  2. RSI 也会给出错误的信号。有些时候，背离被指出，但股票继续其趋势。

Thus, it is always said that we should use the RSI with one or more indicators which will give us a holistic view of the market and help us extract maximum information from the price action of a particular asset.

结论

In summary, once we know how to plot the RSI indicator, it is relatively easy to read it and form an opinion on the asset with the help of the RSI indicator graph. While a general level of 70 indicates overbought and 30 being oversold exists in the market, we have seen that it can be detrimental to rely on this bit of information entirely.

Hence we try to use different strategies on the basis of RSI indicators to give us the necessary confidence to time the market profitably. We also saw that it is always better to use one or more indicator to help us in making more educated guesses in the market.

算法交易策略入门包将帮助你使用能够适应实时市场条件的技术指标创建量化交易策略。

建议阅读:

免责声明:股票市场的所有投资和交易都涉及风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。T3】

基于规则的投资组合，以战胜市场回报

原文：https://blog.quantinsti.com/rule-based-portfolio-project-manoj-hatalage/

该项目的目标是为散户投资者创建一个基于规则的投资组合。对于一个日常工作的普通散户投资者来说，规则的概念和实施应该简单易行。最重要的是，它应该能够击败广泛的指数！

本文是作者提交的最后一个项目，作为他在 QuantInsti 的算法交易管理课程( EPAT )的一部分。请务必查看我们的项目页面，看看我们的学生正在构建什么。

关于作者

Manoj Hatalage pic

Manoj Hatalage 是一名拥有 18 年经验的石油&天然气专家。他在自己的领域拥有各种高度认可的证书。大约三年前，Manoj 对金融市场产生了浓厚的兴趣。

由于没有金融和编程背景，他在寻找交易和投资的系统方法。一门精心设计、包罗万象的 EPAT 课程帮助他获得了未来金融市场之旅的结构化方法。

Manoj 决心在金融领域获得更多的知识，发展自己成熟的量化交易和投资策略。

介绍

市场赚钱难！成功交易者的百分比，我们能够为投资者创造财富的股票的百分比都低于 10%。在全球范围内，许多可能跑赢大盘指数的大型基金的回报率低于 35%至 40%。

我们将根据单一标准对同等权重的投资组合进行回溯测试，并根据广泛的指数评估这些投资组合的表现。对于这个回溯测试，我们将基于五个不同的因素计算投资组合产生的回报。

宽基和智能贝塔指数

目前除了各种宽基指数，还有 NSE 推出的几个 smart beta 指数。各种资产管理公司已经推出了指数基金和交易所交易基金，这些基金可用于其中一些指数。这些指数过去的表现可以从历史数据中计算出来。

因此，与其做我们自己的回溯测试，为什么不投资其中一个指数或者简单地复制它们呢？

这些指数是根据定义的规则创建的，有几个因素会影响这些指数的性能。

这些因素的变化对绩效有什么影响？

让我们看看影响投资组合表现的各种因素。

影响投资组合表现的因素

费用

如果投资者复制指数，投资者将不得不承担交易成本、经纪费和其他直接税。如果投资者通过指数基金投资，他/她将不得不考虑费用率和跟踪误差。

再平衡频率

Smart beta 指数每季度或每半年调整一次。假设某个特定指数每半年进行一次再平衡。如果投资组合每季度或每年重新平衡一次，回报和其他投资组合参数会受到什么影响？

重量

一只股票在指数中的权重是基于一些因素、部门和市场资本总额的。这些指数遵循对股票和行业在指数中权重的限制。我们希望创建一个没有股票或行业权重限制的等权重投资组合。

库存数量

投资组合的表现受到投资组合中股票数量的影响。股票数量多一点或者少一点会有什么影响？

股票领域

这些指数的股票范围主要是大中型股。应该评估扩大股票范围的影响。

所有这些因素对投资组合的影响应该是可量化的，并经过检查以得出确定的结论。

战略

投资组合的设计将基于各种因素。该投资组合的目的是为散户投资者简化投资组合的构建。因此，我们将考虑基本因素，如 Alpha、前一滚动年回报率、波动率、beta 和回报率相对于波动率。

因素(选择标准)

  • 阿尔法:詹森的阿尔法被用作选择标准。詹森的阿尔法是一只股票的回报，超过其理论预期回报。
  • 年度回报:前一个滚动年度的价格回报被用作选择标准。
  • 回报/波动率:前一滚动年价格回报除以年波动率用作选择标准。
  • 贝塔系数:贝塔系数是衡量股票相对于整个市场的波动性。低贝塔股票入围投资组合创建。
  • 波动性:波动性是对给定证券或市场指数的收益分散性的统计度量。年化波动率较低的股票入围投资组合。

投资组合参数

  • 基准指数:Nifty 50，Nifty 100，Nifty 总市场指数。
  • 投资组合中的股票数量:-要测量的投资组合中 15、30、50 只股票的投资组合表现。
  • 权重:等权重投资组合
  • 税收(所得税/ LTCG/STGC): 10%
  • 经纪和交易费用:0.275%
  • 手头现金:投资组合价值或先前现金余额的 10%，以较高者为准。10%的现金部分用于支付交易成本和税款。
  • 因素(选择标准):Alpha、前一年回报、波动性、beta 和回报/波动性。
  • 数据:在 NSE 交易的股票工具的 EOD 数据。
  • 回溯测试持续时间:2008 年 1 月至 2020 年 12 月。
  • 再平衡频率:通过每年、每半年、每季度的再平衡来评估投资组合的表现。
  • 股票领域:根据平均日成交量对不同股票领域的投资组合表现进行评估。

方法学

步骤 1 -计算因子和平均日价值

衡量前一个滚动年度每只股票的因子值和平均周转率值。要么考虑所有股票，要么按日平均交易价值筛选前 750 只股票，并按选择标准进行排序。

步骤 2 -计算当前的投资组合价值

对于初始投资组合，投资组合价值将是初始资本。此外，在重新平衡时，通过每只股票的 CMP *手握数量的总和来计算投资组合价值。如果手头的现金少于投资组合的 10%,通过按照现金部分留出现金来计算投资组合的价值。如果股票退市，取最后一个交易日的收盘价。

第三步-重新平衡

如果投资组合中的股票也出现在新入围的股票中，则买入/卖出该股票，使股票价值=投资组合当前价值/股票数量。计算销售数量的交易成本、利润/损失和税金。

如果投资组合中的股票没有出现在新入围的股票名单中，卖出该股票。计算销售数量的交易成本、利润/损失和税金。

对于当前投资组合中不存在的新入围股票，购买单位数量=(投资组合当前价值/股票数量)/CMP。

第四步-手头现金

交易成本和税收将从库存现金中扣除。在下一次投资组合再平衡期间，通过调整现金余额开始。

结果

使用上述方法，对库存数量、库存范围和再平衡频率的各种组合进行了回溯测试。

在评估各种投资组合的表现之前，让我们先回顾一下同期(即 2008 年 1 月 1 日至 2020 年 12 月 31 日)各种广泛指数和策略(smart beta)指数的价格回报

| Sr 号 | 索引 | CAGR | 最大****下降 | 再平衡频率 |
| 1。 | 俏皮 50 | 6.52% | 60% | 半年一次 |
| 2。 | 漂亮的总市场指数 | 5.92% | 65% | 半年一次 |
| 3。 | 俏皮 100 | 6.70% | 62% | 半年一次 |
| 4。 | 俏皮的低波动 50 | 11.23% | 52% | 季刊 |
| 5。 | 俏皮的阿尔法 50 | 8.21% | 79% | 季刊 |
| 6。 | 俏皮 200 动量 30 | 9.94% | 68% | 半年一次 |
| 7。 | 俏皮的高 Beta 50 | -6.45% | 81% | 季刊 |
| 8。 | 俏皮的阿尔法低波动率 30 | 11.56% | 58% | 半年一次 |

从开始到现在，这些指数的收益和支出数字明显不同。如果我们比 2008 年早 3 年或晚 3 年开始回溯测试，指数和投资组合会显示更好的结果。

我们之所以考虑从 2008 年 1 月 1 日开始的回溯测试期，是因为当前的市场阶段。今天，市场上的每一个人都认为，市场是昂贵的，很快我们可能会看到一个急剧的调整。

投资者最害怕的是什么，然后在部署策略或实施基于规则的投资组合后立即看到大幅调整(缩减)。

因此，在印度市场出现迄今为止最严重的下跌之前，我们已经开始了回溯测试。

| 投资组合表现 | |
| | 股票领域 | 750 | 750 | 750 | 全部 | 全部 | 全部 | |
| 股票数量 | 15 | 30 | 50 | 15 | 30 | 50 | |
| | 返回 | 最大压降 | 返回 | 最大压降 | 返回 | 最大压降 | 返回 | 最大压降 | 返回 | 最大压降 | 返回 | 最大压降 |
| 年度再平衡 | 阿尔法 | 5% | -87% | 4% | -84% | 6% | -82% | 3% | -87% | 4% | -85% | 4% | -84% |
| 年收益 | -2% | -89% | 3% | -83% | 4% | -82% | 0% | -89% | 3% | -83% | 4% | -82% |
| 退货/波动性 | 0% | -85% | 4% | -83% | 6% | -82% | 0% | -86% | 4% | -83% | 6% | -82% |
| 低 _ 贝塔 | 1% | -63% | 6% | -60% | 8% | -64% | 6% | -58% | 8% | -63% | 8% | -65% |
| 低 _ 波动性 | 6% | -50% | 9% | -47% | 9% | -49% | 5% | -50% | 8% | -46% | 9% | -48% |
|   | |
| 半年度再平衡 | 阿尔法 | 6% | -87% | 8% | -84% | 7% | -83% | 9% | -88% | 8% | -86% | 8% | -85% |
| 年收益 | 4% | -86% | 3% | -84% | 5% | -82% | 2% | -87% | 6% | -84% | 6% | -83% |
| 退货/波动性 | 8% | -86% | 6% | -83% | 6% | -82% | 10% | -87% | 9% | -82% | 10% | -82% |
| 低 _ 贝塔 | 3% | -61% | 7% | -60% | 6% | -63% | 10% | -63% | 11% | -65% | 10% | -64% |
| 低 _ 波动性 | 6% | -50% | 8% | -46% | 9% | -48% | 6% | -48% | 8% | -44% | 9% | -46% |
|   | |
| 季度再平衡 | 阿尔法 | 6% | -88% | 7% | -84% | 9% | -81% | 7% | -86% | 7% | -86% | 9% | -84% |
| 年收益 | 9% | -84% | 7% | -83% | 8% | -80% | 6% | -83% | 9% | -84% | 9% | -82% |
| 退货/波动性 | 12% | -83% | 10% | -82% | 10% | -80% | 12% | -84% | 13% | -81% | 13% | -80% |
| 低 _ 贝塔 | 7% | -56% | 8% | -58% | 7% | -60% | 11% | -59% | 9% | -63% | 9% | -65% |
| 低 _ 波动性 | 8% | -45% | 9% | -45% | 10% | -46% | 6% | -45% | 9% | -45% | 10% | -47% |
|   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |

观察

再平衡频率

每年重新平衡的等权重投资组合未能跑赢宽基指数，且提款高于宽基指数，但低波动性投资组合除外，其回报率接近市场，提款较低。

除年度回报投资组合外，半年期投资组合再平衡能够跑赢市场回报。季度再平衡投资组合产生相对较高的回报，除了基于 alpha 的投资组合，因为一些半年度再平衡产生了较高的回报。

无论再平衡频率如何，Alpha 提取、年回报、回报 w.r.t .波动率都高于广泛指数。

库存数量

一些股票对投资组合回报的影响不是结论性的，在一些投资组合中，减少股票数量创造了更高的回报，在一些投资组合中，回报随着投资组合中股票数量的增加而减少。在大多数情况下，当股票数量增加时，最大提取额减少了 2%至 5%以上，但低贝塔投资组合除外，在这种情况下，提取额随着投资组合中股票数量的增加而增加。

股票领域

基于市值过滤股票是一个合适的系统。然而，由于我们无法获得股票的历史市值，我们使用平均交易值来过滤股票。

根据平均每日交易价值筛选出的前 750 只股票的投资组合回报低于全部股票的回报。这可能是由于当我们根据平均每日交易价值过滤股票时，大量交易的几只细价股票被过滤掉了。平均交易价值不应作为筛选股票的市场资本的代理。

回溯测试中面临的挑战

数据 -面临的最大也是唯一的挑战是获取数据！

第一个明显的步骤是尝试通过免费资源获取数据。在我们的回溯测试期间，主要关注的是消除存活偏差，以获得在 NSE 上交易的每只股票的分割和红利调整数据。

还有一个符号变化的问题，合并。对于上市和退市的权益工具，没有单一来源提供分割和红利调整数据。

我们可以从 NSE bhavcopies 获取每个工具的数据，但是 bhavcopies 没有针对拆分和奖金进行调整。退市股票的拆分和分红历史不可用。因此，唯一的选择是获取数据。

但同样，数据供应商也没有在某个时期之前被摘牌的股票的数据。符号变更目录可用，但仅从 1999 年开始。从 2008 年或 2010 年至今的 EOD 数据差异较小。

即使在此期间也很少观察到差异，但仅限于 10 种仪器。这 10 种仪器的未调整数据包含在采购数据中，这可能会对后验测试性能产生轻微影响。

限制

我们比较了仅基于点对点回报的策略。在不同的市场阶段，不同的策略会产生不同的结果。如果我们选择不同的开始日期和结束日期，结果可能会有所不同。这些投资组合的表现应该针对不同的市场阶段进行深入评估。

市场是动态的

进行回溯测试有助于了解各种参数在过去是如何工作的。在历史上或纸面上，战胜市场回报是非常容易的。从长远来看，有新的力量和模式影响着经济和市场。过去行得通的，将来不一定行得通。

滑移

在回溯测试期间，重新平衡日期的收盘价用于计算。实际上，在再平衡日，不可能完全按照收盘价再平衡整个投资组合。这可能会影响投资组合的表现。

交易成本和税收

多年来，税收、佣金和交易成本都发生了变化。交易成本和税收会影响投资组合的回报。此外，我们已经考虑了每个再平衡日的统一税率 10%,该税率将根据各种个人因素从 0%到 30 %不等，如投资资本、投资组合中股票的持续时间、个人的税级，当然还有注册会计师的创造力！

无风险利率

对于回测，不考虑无风险率。投资组合成分和投资组合回报将根据无风险利率而变化。

扩大规模和流动性

我们没有考虑在不影响股票价格的情况下买卖的容易程度。投资组合包括小盘股和小盘股。随着投资组合的增长，我们可能无法以期望的价格退出全部数量。进入和退出时的冲击成本会影响投资组合的表现。在筛选股票时，应该添加一个过滤器，以确保股票的进出不会影响价格。

未来的发展

多因素投资组合:对于这个项目的范围，我们基于单个因素来限制我们的投资组合。基于两个或三个因素的投资组合可能会产生较高的回报和较低的支出。

基于基本标准的投资组合:我们已经基于非常少的因素对投资组合进行了回溯测试，这些因素是基于股票价格的。其他因素，如质量或股票价值，不属于这项研究的一部分。

基于基本面因素或价格、波动性、基本面因素组合的投资组合可能产生更高的回报。

结论

基于回报率相对于波动率和低波动率的季度再平衡投资组合在回溯测试的投资组合中产生了更高的回报率。如果我们单独考虑提款，低贝塔和低波动性投资组合的提款非常低。

这些观察基于截至 2020 年 12 月 31 日的 CAGR 回报。一个单一的因素不一定总是优于其他因素。各种基于因素的投资组合在更短或更长的时间内都优于其他因素。

让我们看看基于低波动性、低贝塔和波动性 w.r.t 回报的季度再平衡投资组合的累积回报的图形表示。

cumulative returns chart

从上面的累积回报图中可以看出，相对而言，波动性较低的投资组合表现稳定。在短时间内和回溯测试期末，相对于波动率投资组合的回报能够超过低波动率和低贝塔投资组合。

值得注意的是，长期以来，w.r.t .波动率投资组合的回报率一直低于宽基指数和低波动率投资组合。如果我们纯粹看一下回测结束时的 CAGR 数据，回报 w.r.t .波动率投资组合可能被视为一个更好的选择。

然而，如果我们看看提款和持续的表现，季度再平衡的低波动性投资组合显然跑赢大盘。

此外，另一个值得注意的观察结果支持了许多学者在许多市场上观察到的 CAPM 的低β异常。与漂亮的高贝塔 50 指数相比，低贝塔投资组合能够以更低的支出产生更高的回报。

如果你想学习算法交易的各个方面，那就去看看这个算法交易课程，它涵盖了统计&计量经济学、金融计算&技术和算法&量化交易等培训模块。EPAT 教你在算法交易中建立一个有前途的职业所需的技能。现在报名！

文件下载:因子组合 Python 代码 Jupyter 笔记本

免责声明:就我们学生所知，本项目中的信息是真实和完整的。学生或 QuantInsti 不保证提供所有推荐。学生和 QuantInsti 否认与使用这些信息有关的任何责任。本项目中提供的所有内容仅供参考，我们不保证通过使用该指南您将获得一定的利润。

一个 Quant 挣多少工资？

原文：https://blog.quantinsti.com/salary-quants-really-earn/

由查尼卡·塔卡

在美国，一般来说，量化专业人士的薪酬在 13 万美元左右(据 Indeed 的数据)。尽管定量分析师的经验、工作角色和专业知识在决定确切薪水时很重要，但定量分析师通常收入颇丰。这篇博客会让你更深入地了解定量分析师的工资以及他们在哪里工作。

给你一个量化交易影响的例子，Man 集团的 AHL 维度计划是一个在量化交易者帮助下的 51 亿美元的对冲基金。

让我们通过这篇博客了解更多关于定量分析师及其薪酬方面的信息，这篇博客包括:

什么是 quant？

简单地说，定量分析师掌握三个领域的知识，即:

  • 金融
  • 数学
  • 编程语言(Python，C++等。)

因此，定量分析师应用数学和统计方法的知识(如数字或量化技术)来解决金融和风险管理问题。quant 应用上述领域的知识来满足任何与交易相关的要求。

例如，为了识别和规避交易某一特定股票的风险，定量分析师将计算风险发生的概率以及所涉及的风险量的可能性。然后，quant 将创建解决方案的计算机算法，以自动方式执行解决方案。

关于定量工资的一切

现在让我们来看看不同地区/国家的定量分析师的平均工资。

| 国家 | 平均基本工资/年 |
| 美国 | $137,475 |
| 印度 | ₹1600 万 |
| 单位 K | £82,298 |
| 加拿大 | c 74 766 美元 |
| 新加坡 | 122，500 新元 |
| 香港 | 407，920 港元 |
| 澳大利亚 | 115 498 美元 |

请注意，这是根据领先的门户网站(如 Indeed、LinkedIn、Payscale 和 Glassdoor)计算的平均基本工资。

此外，重要的是在这里提到，因为大多数人开始作为新生，他们得到的好处，加入奖金和利润分享，这是不包括在基本工资。因此，实际工资更高。

此外，你的技能越好、越相关，潜在公司雇佣你的机会就越大。成为一名定量分析师需要你的努力，但是从职业的角度来看，结果会更有回报。

因此，即使是业余交易者，你也一定可以爬上梯子，有一天成为专业的量化分析师！

注:薪资数字可能因公司、角色、经历和其他因素而异。T3】

成为量化交易者的技巧

我们刚刚提到了增加你被公司聘为定量分析师机会的相关技能。但是，那些相关技能是什么呢？

让我们在这里简要地看一下每项技能:

  • 编程——要成为量化分析师，你必须掌握编程技能。Python 是最受欢迎的计算机语言，被 quants 使用的最多。
  • 概率和统计——交易的一个关键部分是很好的概率和统计知识。基本统计学、时间序列、多元分析等。用于制定战略和风险管理。
  • 市场和经济——对市场和经济如何运作的良好了解有助于量化分析师在行业中生存。
  • 分析性思维——个人的分析性思维和运用强有力的推理解决问题的能力发挥着重要作用。

因此，这些是成为量化分析师最重要的技能。根据 quant 域中每个角色的工作职责，使用技能。

定量分析师的工作职责

作为一名新生，量化分析师将和其他量化分析师一起在团队中工作，创建交易相关的模型或策略。

通常，量化员的工作职责要求个人执行以下任务:

  • 交易庞大的投资组合。
  • 分析数百千兆字节的数据，以确定微观行为模式(在微秒时间框架内),并在此类信号下进行交易。
  • 同时，在交易时，分析跨时间和跨资产的信息，以构建宏观信号。
  • 借助算法创建自动交易信号。
  • 交易时进行风险管理。
  • 发现并模仿逻辑，从而自动设置交易者每天交易的数百个参数或条件。

但是随着你的晋升，你将能够处理更多的事情。让我们看看量化分析师的各种工作角色，如下所示:

  • 初级分析师
  • 量化分析师
  • 定量研究分析师
  • 高级定量分析师

注意:工作职责可能因公司、角色、经历和其他因素而异。T3】

quants 在哪里就业？

这个问题的简单答案就是，量子基金！

在我们开始讨论什么是量化基金之前，有必要提一下，有抱负的个人需要通过量化面试才能开始做量化基金。

乍一看，你可能会想——量化基金有什么大不了的？

它一定是我们今天拥有的众多选择中的又一个，比如指数基金、共同基金等等。但是深入研究，你会发现量化基金正在缓慢但肯定地在这个行业站稳脚跟。

如果你看看美国市场，两个大牌是文艺复兴科技和两个适马。虽然复兴科技拥有 1300 亿美元的 aum⁽⁾(2021 年 4 月)，但据报道，两西格马管理着 580 亿美元的 aum⁽⁾(2020 年 1 月)。

因此，在多元化时代，量化基金创造了寻求相对结构化基金的投资者的需求。这也增加了对数量已经很少的定量分析师的需求。

虽然大多数基金公司肯定会将利润分享作为薪酬方案的一部分，但也有无数的量化分析师建立了自己的算法交易平台。

定量分析师的未来

在金融领域，尤其是交易领域，定量分析师受到追捧是有原因的。

过去，手工交易者使用技术分析工具和基本面分析来衡量股票是否值得投资。随着时间的推移，建立了复杂的数学模型来评估交易的盈利能力。

在寻求开发一个避免人类情绪的合理交易策略的过程中，这些模型变得越来越复杂，越来越难以实施。这就是程序员的作用所在，他们为模型开发算法。

随着时间的推移，人们意识到我们不需要三个不同的人来完成这项任务，因为一个训练有素的专业人员可以很容易地单独完成。

展望未来，在未来五年内，据预测，对定量分析师的需求将大幅增长。这可以从下图中看出。

Future of quants

Source: FitchLearning

与算法交易员的坦诚对话

让我们看看我们从与一位成功的算法交易者的坦诚对话中获得的有趣而有用的信息。交易员本人的提问和回答如下:

如何搭建 algo 艾格书桌？

算法交易是一个过程，使用一套指令以人类不可能的数量和速度下单购买或出售脚本。这组指令基于各种市场指标，如价格、时间、数量和任何其他用户偏好。

algo 交易的好处在于它消除了人工干预，从而使交易没有情绪和直觉。

一个典型的算法系统的架构需要三个主要组件

  • 市场数据处理器
  • 战略模块
  • 订单路由器

顾名思义，市场数据处理器接收市场数据并存储它。数学模型中的交易策略被输入到策略模块。它也是市场和交易者之间的接口。

订单路由器或管理器将订单发送回交易所进行买卖。

要建立一个 algo desk ，作为一名经纪人，你需要确定你的协同位置，将服务器放在离交易所很近的地方，在对系统进行回溯测试和验证后，将你的策略输入到你的系统中，有一个良好的互联网连接，我认为你可以开始了！

你建议进入这个领域的步骤是什么？

嗯，第一步也是最重要的一步是建立一个坚实的基础。学习一些编程技巧，把握市场。擅长数字总是有帮助的。

从探索统计学和计量经济学等核心学科开始。像欧内斯特·陈的《量化交易》或拉里·哈里斯的《交易与交换》这样的书可以详细说明如何建立一个“合适的”算法交易系统。

当你完成了上面提到的步骤后，就开始着手战略建设、建模技术和统计工具。

掌握各种交易策略范例，如统计套利、执行策略、买卖价差。在 Quantra 、Udemy 和 Udacity 上有一些免费的在线课程，非常适合试水。对于认真的学习者，还有其他付费的高级课程。

哪些是交易者常用的编程语言？

就高频交易(HFT)而言，C++仍然是最受欢迎的语言。原因是与其他语言相比，C++中的内存泄漏和相关错误要少得多。

Python 已经成为编码策略和回溯测试的主要方式，因为它更容易掌握，并且有良好的科学库支持，如 Numpy 和 Pandas 。

今天，许多论坛讨论用 Python 程序编码的投资和交易策略。

散户如何参与算法交易？

与传统的交易终端相比，设置成本肯定是偏高的。获得协同定位可能是一件昂贵的事情。

根据最近的统计数据，华尔街近 70-80%的交易是使用算法执行的，主要是由大型机构投资者和对冲基金执行的。

然而，随着基于网络的平台的出现，零售参与者的情况正在发生变化。对于不太关心延迟的人来说，它非常管用。除此之外，像 Interactive Brokers 这样的公司为零售客户提供 API 和软件包，这样交易者就可以对他们的策略和交易进行编码。

一旦你掌握了它，它就像一个简单的 Gmail 帐户。你登录你的账户，测试你的策略，执行回溯测试，优化后，在实时市场交易。

也强烈推荐纸上交易或在模拟器上测试。

印度算法交易的生态系统如何？考虑到算法交易的利基类别和高技能从业者的参与，公司是否愿意选择算法交易？

SEBI 于 2008 年允许算法交易。在 8 年的时间里，近 50%或更多的交易是基于算法的。这说明了它的受欢迎程度。

印度交易所很好地适应了这种变化，积极参与者稳步增加。fii 和国内基金都使用 Algo 路线下单。

交易的未来是什么样子的？

实际上，交易的未来似乎很有希望。很明显，自动化是驱动世界的未来。无论是在哪个领域，自动化正在从传统道路上进行一场结构性转变，这同样适用于股票市场。在美国市场，70-80%的交易量是通过自动化系统进行的。

像印度这样的新兴市场正在见证该领域的指数级增长。当然，市场每天都在成熟，所以交易成本会在某一点后降低。

一个典型的例子是:汽车工业，在引进机器人后，最初人们认为该行业由于资本成本高而难以为继。

一个初学者在涉足这个领域时应该记住哪些事情？

最重要的一点是，光有好的交易策略是不够的，还要有竞争优势。

它可以是具有颠覆性的创新想法，也可以是低佣金或你可以进入的那种市场，但如果你想成功，你必须有一个杀手级的提议。像对待任何常规业务一样对待它，你必须制定策略来智胜竞争对手。

对于新手来说，弄清楚这个行业的细微差别是很重要的。

如果我想进一步了解这个领域，我下一步应该做什么？

最好的方法是找专家和领域权威来交谈，讨论你的疑惑。尝试互联网上免费提供的工具和资源。做好接受新知识和发展新技能的准备！

这些只是交易者自己回答的几个问题。你怎么想的，你对如何成为一名量化分析师或建立自己的办公桌有什么疑问吗？你可以在下面留言，我们会尽快回复。

结论

成为量化分析师不仅回报丰厚，而且非常有趣，因为量化分析师为高度专业的公司工作，有一些额外津贴。

毫无疑问，量化分析师的成功之旅需要大量的努力和奉献。但是，一旦你进入量化基金或者投行做量化师，职业范围是巨大的！

如果你想了解更多关于 quant 的知识，你必须通过我们的 algo 交易课程学习算法交易。你将能够获得成为成功的量化交易者所需的必要技能，如编程、统计、数据分析和建模等。

此外，EPAT 是一个深入的学习经历，因为它是一个成熟的计划，因此，将帮助您学习所需的概念细节。

我们祝您在 quant 之旅中一切顺利！

免责声明:股票市场的所有投资和交易都涉及风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。T3】

Scikit 学习教程:安装、要求和构建分类模型

原文：https://blog.quantinsti.com/scikit-learn-tutorial/

由阿舒托什·戴夫

Scikit-learn 是最通用、最高效的机器学习库之一。scikit learn 建立在其他流行的库(如 NumPy、SciPy 和 Matplotlib)之上，包含许多用于机器学习和统计建模的强大工具。难怪 scikit learn 被数据科学家、研究人员和学生广泛使用。大型组织正在使用 scikit learn 从数据中获取洞察力以制定业务决策。

在这篇博客中，我们将了解如何利用 Scikit Learn 的强大功能和简单性来构建一个分类模型(也称为分类器)并逐步调整其参数。
T3T5T7】

我们将在本 Scikit 学习教程中涵盖以下主题

让我们从基础开始，即安装和导入 scikit 学习库:

安装和导入 scikit learn

可以使用以下标准命令在 jupyter 笔记本环境中安装和导入 Scikit learn:

在[5]中:

!pip install scikit-learn
import sklearn

那很简单！在下一节中，我们将讨论 scikit learn 中的数据要求。

在 scikit learn 中处理数据的要求

在我们开始使用 scikit learn 训练我们的模型之前，让我们了解机器学习中的以下命名约定:

  • 特征=预测变量=独立变量
  • 目标变量=因变量=响应变量
  • 样本=记录=实例

在使用 scikit 学习库训练模型之前，它对数据有以下要求:

接下来，我们将看到一个符合上述要求的数据集示例，用于 scikit learn。

虹膜数据集

Scikit learn 附带了一些标准数据集。其中之一就是著名的虹膜数据集，它是由统计学家 R. A. Fisher 爵士在 1936 年首次提出的。
该数据集用于解决一个简单的分类问题，其中我们必须预测鸢尾花的物种(Setosa、Versicolor 或 Virginica ),给定一组以厘米为单位的测量值(萼片长度、萼片宽度、花瓣长度和花瓣宽度)。

鸢尾数据集有 150 个鸢尾花的实例，对于每个实例，我们有上述四个测量值(特征)和物种代码(响应)。
响应以物种代码的形式出现(0、1 和 2 分别代表刚毛藻、云芝和海滨锦葵)。这便于我们在 scikit learn 中使用它，因为根据上述要求，特征和响应数据都应该是数字。

让我们从 scikit 学习库的“数据集”子模块中获取虹膜数据集，并使用以下命令将其保存在名为“Iris”的对象中:

在[6]中:

from sklearn import datasets
iris= datasets.load_iris()

“iris”对象属于类 Bunch，也就是说，它是以类似字典的格式捆绑在一起的各种对象的集合。这些对象包括特征矩阵“数据”和目标向量“目标”。我们将把它们分别保存在对象 X 和 y 中:

在[7]中:

#storing feature matrix in "X"
X=iris.data
#storing target vector in "y"
y=iris.target

现在让我们检查这两个物体的类型和形状:

在[8]中:

#Printing the type of X and y to check if they meet the NumPy array requirement
print(" type of X:",type(X),"\n","type of y:",type(y))
#Printing the shape of X and y to check if their sizes are compatible
print(" shape of X:",X.shape,"\n","shape of y:",y.shape)


 type of X: <class 'numpy.ndarray'>
 type of y: <class 'numpy.ndarray'>
 shape of X: (150, 4)
 shape of y: (150,)

我们看到 X 和 y 的类型是 numpy ndarray，其中 X 有 150 个实例，有四个特征，y 是一个一维数组，有 150 个值。

太好了！我们看到 scikit learn 中使用 X 和 y 作为特征矩阵和响应向量的所有三个要求都得到了满足。

将数据分为训练集和测试集

在我们开始建模过程之前，将数据分成训练集和测试集总是一个好主意，以避免过度拟合的问题。当模型对其训练的数据点具有高预测能力，但对样本外或新数据的概括能力较差时，就会发生过度拟合。

当我们只使用训练集来训练模型时，我们仍然有测试集来检查模型的性能。因此，拆分数据有助于我们评估数据的样本外准确性，因为测试数据集是新的或模型看不到的。

我们可以使用 scikit learn 的模型选择子模块中的 train_test_split()函数轻松实现这种分割:

在[9]中:

#importing the train_test_split function from the model selection submodule of scikit learn library
from sklearn.model_selection import train_test_split
#Splitting X into Xtrain and Xtest while splitting y into ytrain and ytest
X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=0.25, random_state=123, stratify=y)

我们已经将该函数中 test_size 参数的值设置为 0.25。这意味着我们将 25%的数据保留在测试集中，并将剩余的 75%用作模型的训练集。我们还设置了一个任意的“随机状态”(或种子)，以便以后可以重现我们的结果。最后，我们根据目标变量对样本进行了分层。这确保我们的训练集看起来与测试集相似，使评估指标更加可靠。

接下来，我们将使用我们创建的数据集来说明 scikit learn 中的模型开发步骤。

使用 Scikit learn 构建分类模型的步骤

在 scikit learn 中创建学习模型的整个生命周期可以大致分为五个步骤。我们现在将详细介绍每个步骤，并使用虹膜数据上的 k 最近邻分类算法作为示例。k 近邻(kNN)是最简单的学习策略之一:它简单地存储所有训练数据，对于任何未知量，简单地返回最近训练点的标签。

步骤 1:从 scikit learn 中特定算法所属的“类”或“族”中导入该算法

有一些算法家族(或类)在方法论上共享一些方面。例如，线性回归和逻辑回归算法都属于 scikit learn 中称为线性模型的家族。对于本博客的范围，我们将只关注训练一个 kNN 分类器并调整其参数。kNN 算法属于 scikit learn 中的“neighbors”类，可以按如下方式导入:

在[2]中:

# importing the kNN classifier from the neighbors submodule of scikit learn
from sklearn.neighbors import KNeighborsClassifier

步骤 2:实例化算法，以创建具有特定超参数的“估计器”或“模型”

作为学习模型的一部分，我们处理两种参数:超参数和模型参数。超参数表示关于模型的结构信息，通常由模型开发者在数据适合模型之前选择。另一方面，模型参数可以直接从数据中学习和优化(例如回归系数)。

kNN 算法有一个超参数 k(又名 n_neighbors) ，作为模型开发人员，我们必须选择这个超参数来获得数据的最佳拟合。直观上，我们可以认为 k 控制着标签之间决策边界的形状。

举例来说，现在让我们在 scikit learn 中创建一个 kNN 分类器实例，超参数 k=6，并将其保存在名为 knn6 的对象中:

在[10]中:

# instatntiating the kNN classifier using scikit learn with k=6
knn6 = KNeighborsClassifier(n_neighbors=6)

关于 scikit learn 需要注意的另一点是，超参数的缺省值非常通用。对于 knn6 分类器，其他超参数(其值我们没有明确给出)如 leaf_size、metric、weights 等。被设置为默认值。

现在让我们来看看我们使用 scikit learn 创建的 knn6 对象:

在[11]中:

knn6

Out[11]:

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
 metric_params=None, n_jobs=1, n_neighbors=6, p=2,
 weights='uniform')

我们可以观察上面 scikit learn 提供的超参数默认值。在下一步中，我们将看到如何使 knn6 分类器适合 scikit learn 中的数据。

步骤 3:使模型符合训练数据(即在 scikit learn 中“训练”模型)

只有在我们将分类器与数据相匹配之后，我们才能得到一个实际的模型。先前创建的 knn6 估计器都被设置为从训练数据集“学习”。我们现在将使用简单的命令将特征矩阵 X_train 和响应向量 y_train 输入到 knn6 估计器中:

在[12]中:

# Fitting the knn6 classifier object to the training data
knn6.fit(X_train, y_train)

Out[12]:

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
 metric_params=None, n_jobs=1, n_neighbors=6, p=2,
 weights='uniform')

就是这样！我们现在已经使用一行简单的代码训练了我们的模型。这展示了 scikit 学习库的强大功能和易用性。在下一步中，我们将看到如何使用我们刚刚训练的模型在 scikit learn 中进行预测。

步骤 4:预测测试数据的响应

我们现在可以根据看不见的或新的数据做出预测。例如，如果我们随机选择一朵新的鸢尾花，并测量四个特征值，我们的模型现在可以根据它从训练数据集中学习的内容来预测花的种类。假设测得的特征值如下:

让我们将特征值保存在名为 X_new 的对象中，并使用 knn6 估计器来预测物种代码:

在[13]中:

#saving the feature values for this in an object called X_new
X_new = [[3, 2, 3.3, 2.9]]
#predicting the species code of the new flower using knn6 classifier
knn6.predict(X_new)
#printing the results
print(knn6.predict(X_new))
print(iris.target_names[knn6.predict(X_new)])


[1]
['versicolor']

我们的模型已经预测新的花属于鸢尾的 Verscicolor 类型，其响应值为 1。

类似地，我们现在将预测测试数据(X_test)中所有 38 个实例的响应值，并将预测保存在 y_pred 中:

在[15]中:

#predicting the specie codes for all instances in the test data
y_pred=knn6.predict(X_test)
# printing the results of pediction
print(y_pred)
print(iris.target_names[y_pred])


[2 0 1 2 0 0 1 2 1 0 1 0 2 2 1 2 0 0 0 0 0 0 1 2 0 2 2 1 2 1 1 2 1 1 2 1 2
 1]
['virginica' 'setosa' 'versicolor' 'virginica' 'setosa' 'setosa'
 'versicolor' 'virginica' 'versicolor' 'setosa' 'versicolor' 'setosa'
 'virginica' 'virginica' 'versicolor' 'virginica' 'setosa' 'setosa'
 'setosa' 'setosa' 'setosa' 'setosa' 'versicolor' 'virginica' 'setosa'
 'virginica' 'virginica' 'versicolor' 'virginica' 'versicolor'
 'versicolor' 'virginica' 'versicolor' 'versicolor' 'virginica'
 'versicolor' 'virginica' 'versicolor']

既然我们已经预测了测试数据中所有数据点的种类，我们现在可以继续确定和改进我们预测的质量。这将是我们的下一步，即 scikit learn 中的模型评估。

步骤 5:模型评估:微调 scikit learn 中的分类模型

在前四个步骤中，我们开发了一个模型，并对测试数据进行了预测。现在我们进入模型评估阶段，在此阶段，我们将通过 scikit learn 实现以下目标:

  • 量化我们模型的性能
  • 估计我们的模型在样本外数据上的性能
  • 为模型选择最佳的调整参数集

让我们首先看看如何使用混淆矩阵和准确度分数来量化我们的模型在 scikit learn 中的性能:

混淆矩阵和准确度分数

为了衡量我们的模型的准确性，并能够将其与其他模型进行比较，我们需要可以将预测值(y_pred)与实际值(y_test)进行比较的度量。Scikit learn 以混淆矩阵的形式让我们轻松完成这项任务。

混淆矩阵通常用于总结分类模型的预测结果。正确和错误预测的数量以每个标签分解的计数值表示。现在让我们为我们的分类器做出的预测建立一个混淆矩阵:

在[16]中:

# importing confusion_matrix function from the metrics sub-module of scikit learn
from sklearn.metrics import confusion_matrix
print(confusion_matrix(y_test,y_pred))


[[12 0 0]
 [ 0 12 1]
 [ 0 1 12]]

混淆矩阵显示了模型在预测标签时的“混淆”。例如，在上面的矩阵中，我们可以看到 knn6 分类器在最后两个标签之间有些混淆，因为在非对角线位置存在非零值。然而，困惑只存在于测试数据的 38 个观察值中的两个。这意味着 38 次预测中有 36 次是准确的。这可以通过称为准确度分数的指标量化为百分比，也是 scikit learn 中指标子模块的一部分:

在[17]中:

# importing accuracy_score function from the metrics sub-module of scikit learn
from sklearn.metrics import accuracy_score
print("accuracy score=",accuracy_score(y_test,y_pred),"\n")


accuracy score= 0.9473684210526315

我们的模型具有 0.947 的准确度分数，即来自测试数据的几乎 95%的观察值被正确分类。

仅使用测试序列分割的问题

我们利用测试数据集(我们的模型仍然看不到)来验证模型。理论上，在测试数据集上计算的准确性度量应该给我们一个对我们的模型在看不见的/新的或不在样本数据上的性能的合理估计。

但是，有风险。如果我们将整个数据集的另一个子集作为训练数据集，模型性能可能会发生显著变化。这导致了我们的模型做出的预测的变化，并且我们的模型基于随机选择的训练-测试对可能看起来或多或少更熟练。

另一个问题是，当我们拆分数据并对训练过程隐藏测试数据时，我们可能会丢失对训练模型有价值的信息。这是一个更大的问题，特别是当我们希望在操作环境中部署模型，并且我们没有大量的数据时。

处理这些问题的一个流行的解决方案是使用 K 倍交叉验证。

scikit 学习中的 k 倍交叉验证

K-交叉验证(此 K 不同于 kNN 分类器的 K)是一种统计技术，涉及将数据划分为大小相等的“K”个子集。该模型在(K-1)个子集的数据上训练，并且剩余的一个子集被用作验证该模型的测试数据集。我们执行多轮上述过程，直到所有 K 个子集都被用于验证一次。然后，我们将这些多轮验证的结果结合起来，得出对模型性能的估计。

Image

来源

上述过程减少了可变性，因此 K 重交叉验证为我们提供了对样本外数据的模型性能的更准确的估计。现在让我们在 scikit learn 中为我们的模型实施 10 重交叉验证:

在[20]中:

# importing cross_val_score function from the model_selection sub-module of scikit learn
from sklearn.model_selection import cross_val_score
# Saving the accuracy scores for a 10 fold cross validation in Accuracy_scores
Accuracy_scores = cross_val_score(knn6, X, y, cv=10, scoring='accuracy')
#Printing all 10 accuracy scores
print(Accuracy_scores)


[1\. 0.93333333 1\. 1\. 0.86666667 0.93333333
 0.93333333 1\. 1\. 1\. ]

在[21]中:

# Taking the average of all 10 accuracy scores
print(Accuracy_scores.mean())


0.9666666666666668

与之前获得的 0.9473 相比，平均值 0.9666 是对我们模型准确性的更好估计，即我们最初的训练测试分割低估了 knn6 模型对样本外数据的预测能力。

使用 scikit learn 中的 GridsearchCV 进行超参数调整

早些时候，我们已经随机选择了我们的 kNN 模型的超参数 k 的值为 6，并且方便地将我们的模型命名为 knn6。我们将所有其他超参数保留为默认值。然而，我们不知道这组超参数是否在三种鸢尾物种之间产生最佳决策边界。因此，一种更好的方法是使用一种算法来自动找到特定模型的最佳参数集，而不是通过试错来找到参数值。GridSearchCV 就是这样一种算法，它可以找到我们正在寻找的一组最佳超参数值。

GridSearchCV 利用交叉验证概念(前面讨论过)来寻找超参数值所有可能组合的精确度，并且自动寻找并拟合最佳组合。

让我们考虑到目前为止我们已经考虑过的 kNN 算法的例子。假设我们想要调整 kNN 模型的两个超参数，即:

  • n _ 邻居(又名 k)和
  • 叶子大小

我们可以为这些参数定义一个包含潜在值的对象，如下所示:

在[18]中:

# importing GridSearchCV algorithm from the model_selection sub-module of scikit learn
from sklearn.model_selection import GridSearchCV
#Define an object containing hyperparameter name and potential values as key-value pairs
hyperparameter_values = {'n_neighbors':[1,3,5,7,9,11], 'leaf_size':[20,25,30,35,40]}

因此，对于超参数值总共有三十(6×5)种可能的组合，因此对于 kNN 估计量有三十种可能性。
让我们实现 GridSearchCV 算法，找出最佳算法，然后将数据拟合到该算法中:

在[24]中:

# Instantiating the GridSearchCV algorithm
gs=GridSearchCV(KNeighborsClassifier(),hyperparameter_values,cv=10)
# fitting the data
gs.results=gs.fit(X,y)

我们在这里所做的类似于对 30 个可能的估计值中的每一个进行 10 重交叉验证，并将最佳结果保存在名为“gs”的对象中。我们现在可以访问最佳估计值、参数值和准确度分数，如下所示:

在[37]中:

print('Best estimator/model: ',gs.results.best_estimator_)
print('Best parameter combination: ',gs.results.best_params_)
print('Best accuracy score: ',gs.results.best_score_)


Best estimator/model: KNeighborsClassifier(algorithm='auto', leaf_size=20, metric='minkowski',
 metric_params=None, n_jobs=None, n_neighbors=9, p=2,
 weights='uniform')
Best parameter combination: {'leaf_size': 20, 'n_neighbors': 9}
Best accuracy score: 0.9733333333333334

最佳估计值是 k(n_neighbor)值为 9 且 leaf_size=20 的 kNN 模型，其产生的准确度得分为 0.9733，比先前计算的 knn6 估计值的交叉验证得分 0.966 有显著提高。

保存最佳模型以备将来使用

既然我们已经努力构建了一个最佳模型，我们可以使用 joblib 库(joblib 包含一组在 Python 中提供轻量级管道的工具)将它保存为 pickle 文件以供将来使用，如下所示:

在[40]:

# !pip install joblib (if not installed already)
import joblib
#Save model for future use with a pickle file extension
joblib.dump(gs, 'kNN_optimized.pkl')
#To load it back use
joblib.load('kNN_optimized.pkl')

Out[40]:

GridSearchCV(cv=10, error_score='raise-deprecating',
 estimator=KNeighborsClassifier(algorithm='auto', leaf_size=30,
 metric='minkowski',
 metric_params=None, n_jobs=None,
 n_neighbors=5, p=2,
 weights='uniform'),
 iid='warn', n_jobs=None,
 param_grid={'leaf_size': [20, 25, 30, 35, 40],
 'n_neighbors': [1, 3, 5, 7, 9, 11]},
 pre_dispatch='2*n_jobs', refit=True, return_train_score=False,
 scoring=None, verbose=0)

结论

因此，我们已经了解了如何安装和导入 scikit 学习库。我们还使用 scikit learn 完成了训练和优化分类模型的所有步骤。在下一篇博客中，我们将探讨如何在 scikit learn 中训练和微调回归模型。

快乐学习到那时！

有许多人可能是 Python 或编程的新手，或者从未创建过任何交易策略。如果你是这两种技能的初学者，学习曲线可能会很陡。然而，你可以通过在这里注册来逐步建立所需的技能，并定期练习我们课程中给出的实践学习练习:人人算法交易。

如果你想学习算法交易的各个方面，那就去看看我们的算法交易(EPAT ) 高管课程。课程涵盖统计学&计量经济学、金融计算&技术和算法&定量交易等培训模块。EPAT 旨在让你具备成为成功交易者的正确技能。现在报名！

免责声明:股票市场的所有投资和交易都有风险。在金融市场进行交易的任何决定，包括股票或期权或其他金融工具的交易，都是个人决定，只能在彻底研究后做出，包括个人风险和财务评估以及在您认为必要的范围内寻求专业帮助。本文提到的交易策略或相关信息仅供参考。

SEBI 延长市场时间准则及其对交易商的影响

原文：https://blog.quantinsti.com/sebi-guidelines-extended-market-hours-impact-traders/

SEBI Guidelines On Extended Market Hours And Its Impact On Traders

由尼廷·塔帕尔

印度证券交易委员会(SEBI)已批准将股票衍生品合约的交易时间延长 8 小时以上，这是一项历史性举措。目前，交易时间为上午 9:15 至下午 3:30，可能会从 2018 年 10 月 1 日 st 起调整至晚上 11:55。

“为了在交易所层面整合证券市场的各个部分的交易，已决定允许证券交易所将股票衍生品部分的交易时间设定在上午 9 点至晚上 11 点 55 分，前提是证券交易所及其结算公司建立了与交易时间相称的风险管理系统和基础设施，”SEBI 在通知中说。

SEBI 的点头并不意味着时间窗口的延长会通过。为了使其有效，证券交易所(NSE 和 BSE)必须按照要求实施和扩大规模。

有趣的是，与世界各地的其他交易所相比，只有法兰克福证券交易所开放 12 小时，即从早上 08:00 到晚上 08:00，而世界上所有其他交易所根据国家的工作时间运营 5 到 6 个小时。

世界主要证券交易所的交易时间:

Trading hours of some of the world's major stock exchanges

言归正传，这个决定会对市场和交易者产生什么影响？

对市场和交易者的影响

1。印度市场将与国际市场接轨

印度市场将与国际市场(尤其是亚洲市场)接轨，但交易量可能会分散在不同的时间段，这可能会导致初始阶段的交易深度较低。

BSE 医学博士兼首席执行官 Ashishkumar Chauhan 说“(在印度)引入延长工作时间是一个积极的发展，将使印度市场与国际市场接轨。”

2。经纪人需要适应这一新变化

经纪人将不得不通过改变当前的执行、风险管理政策来适应这些延长的交易时间，可以见证额外资源的需求以满足更长的交易时间，并且可以预期更多这样的变化，但具有更高的交易周转率的好处。

3。投资者的更多机会

投资者(主要是执行大宗订单的自动交易者)有更多机会在正常交易时间之外对冲市场风险。

“如果在印度现货市场收盘后发生任何事件，这仍然为印度投资者提供了对冲风险的机会。”NSE 总裁、医学博士&vik ram Limaye 说

4。外国市场影响的变化

国外市场发生的新闻和事件对印度市场的剧烈影响将会减少。与以前不同的是，在外国市场发生重大事件后，市场在新的交易日开始时表现出极端的趋势变化

5。波动率分布

市场波动将分布在更长的交易周期内。依赖高波动性的全权交易者可能不得不改变策略或选择自动化交易，因为波动性将在更长的交易时间内持续。

6。外国投资者数量增加

由于延长交易时间将吸引外国投资者，流动性的增加是显而易见的。这也意味着传统的交易者必须提高他们的游戏，因为他们将与有多个市场经验的交易者竞争，即“缺口上升”或“缺口下降”的情况。

7。多个交易时段

这也为多个交易时段带来了机会(尽管 SEBI 尚未提出)，一些散户交易者和几乎所有的自动交易者可以通过在这些时段的休息期间改革他们的交易策略来利用这些机会。

8。衍生品的公平价格

由于许多印度衍生品都在国外市场上市，增加交易时间有助于发现这些衍生品的公平价格

9。其他因素

最后但并非最不重要的一点是，这也可能意味着压力增加、工作时间延长，以及需要提高零售交易员的效率。经纪费将会上涨，以迎合这些经纪人承担的更长的工作时间和升级技术的成本。

对这一决定的反应不一，并非所有人都同意或不同意这一改变。重要的是，作为交易者，你如何充分利用这个机会。

延长交易时间前需要考虑的事项

1。自动交易

随着在办公桌前工作时间的增加，散户投资者用全权委托的方式监控和分析市场会变得很有压力。自动化交易可能是未来的发展方向，在这种情况下，算法可以用来对不断变化的市场形势做出反应，而不会在交易时间较长的情况下被自己的情绪冲昏头脑。

2。学会竞争

随着越来越多的投资者(印度和外国)进入市场，竞争将会加剧，对新技术的需求也将增加，从而比其他投资者更具优势。你需要升级你的策略，让机器为你交易，从实时波动中获益。你可以利用的多种学习机会来获得所需的优势。

3。利用基于职业的机会

毫无疑问，对技术人才的需求将会增加。院校将寻找能够带来经验和技能的人才，以满足他们的需求。这是传统交易者提升技能的好时机，这可以帮助他们获得更好的机会加入下一代的算法和量化交易者联盟。

4。能帮你赢的技能

随着波动性在更长的交易时间内分散，处理大宗订单的策略将发挥关键作用，先进的技术(如情绪分析、回溯测试、预测等)也将发挥重要作用。)将帮助你应对不断变化的市场环境的影响。

我们将不得不等待交易所按照 SEBI 提出的条件实施并准备好所需的变化，这些条件要求建立有效的风险管理系统并做好基础设施准备。但是作为一个投资者，你可以记下上面提到的可以帮助你开始的几点。

SEBI 将很快出台新的算法交易指导方针

原文：https://blog.quantinsti.com/sebi-new-guidelines-algorithmic-trading/

UK Sinha, SEBI Chairman

阿努普里亚·古普塔

SEBI 证券交易委员会主席 U K .辛哈最近表示，SEBI 将很快出台一套新的算法交易指导方针。新规定将抑制高订单交易比率，阻止在没有执行这些交易的意图下订单的做法。我们还可以期待交易所在算法上线前出台新的测试规则。

根据 SEBI 制定的现有指导方针，交易所和监管机构(SEBI)会定期进行审计，以确保指导方针得到遵守。对于使用算法交易或提供算法交易设施的股票经纪人，规定每半年审计一次。

相关帖子:

SEBI 建议的审计框架可在其网站上查阅。算法交易员属于第三类经纪人，审计框架文件明确规定了审计师在撰写报告时需要检查和考虑的领域。健全的风险管理系统是审计的一个重要方面，它要求建立在线实时风险管理系统和交易限额。审计过程中发现的或向交易所和经纪人报告的不足和问题必须立即采取纠正措施。

SEBI 和交易所的审计对股票经纪人来说是必要的，以避免他们的巨大错误，这对他们自己和市场都是灾难性的。

为了能够很好地管理风险，同时允许市场智能地增长，需要对算法交易、网络和相关技术有透彻的了解。至关重要的是，要让市场保持灵活，自我调整，同时避免因人为或机器错误造成的损失和崩溃，就必须允许制衡和杠杆的最佳组合。我们希望 SEBI 和全球其它监管机构的这种努力，将在全球范围内形成一个更成熟、更安全的市场。

如果你是一名散户交易者或专业技术人员，想要建立自己的自动化交易平台，今天就开始学习算法交易吧！从基本概念开始，如自动交易架构、市场微观结构、策略回溯测试系统和订单管理系统。你也可以报名参加 EPAT，这是业内最广泛的算法交易课程之一。

SEBI 发布关于算法交易和协同定位的讨论文件

原文：https://blog.quantinsti.com/sebi-paper-algorithmic-trading-co-location-july-2016/

SEBI releases discussion paper on Algorithmic Trading & Co-Location 图片来源:路透社

SEBI 今天发布了一份讨论文件，其中包括投资者、基础设施机构和中介等所有利益相关者的投入，以了解算法交易近年来如何导致公平、担忧和市场质量的变化。

它指出，在大多数交易所交易的产品上，超过 80%的订单是由算法生成的，这些订单占交易所交易的大约 40%。

这项研究引用了表明算法交易利弊的现有文献。

算法交易的优点

  • 提高市场质量
  • 利差收紧
  • 更好的流动性

算法交易的缺点

  • 非算法交易者的逆向选择成本
  • 与前算法/前托管时代相比，增加了“快速崩溃”的可能性

概述

从 2008 年起，当 SEBI 允许印度直接进入市场时，印度在维持监管和执行审计检查方面发挥了至关重要的作用！

该文件强调了不同的监管可能性，SEBI 目前正在分析与订单休息时间、连续匹配系统、订单处理延迟、订单随机化和最大订单信息交易比率相关的监管可能性。

为了能够很好地管理风险，同时允许市场明智地增长，需要对算法交易、网络和相关技术有透彻的了解。至关重要的是，要让市场保持灵活，自我调整，同时避免因人为或机器错误造成的损失和崩溃，就必须允许制衡和杠杆的最佳组合。我们希望 SEBI 和全球其它监管机构的这种努力，将在全球范围内带来更成熟、更安全的市场。

点击阅读整篇文章。它邀请公众对提案和讨论的理由和数据发表意见。

证券主系统说明

原文：https://blog.quantinsti.com/securities-master-system/

Securities Master System

Java 开发人员 Gasa Mzolo

作为一名开发者，我们只需点击一个按钮，就可以获得大量的技术，我们中的许多人往往关心从头构建一个程序并最终看到它工作的乐趣。希望这种需求不会从一种更高的力量改变，这种力量基本上让我们的内心充满了足够的压力，如果这种压力转化为毒药，就会杀死一整群老鼠。然而，他们确实让我们心中充满了快乐，对吗？！这些更高的权力只关心最终产品的工作，而不关心它是如何建造的艺术。同样，还有许多程序员不认为是艺术的工作，这就是我今天的重点。

数据库设计和管理是我们经常要做的工作之一。在计算投资领域，就像在编程领域一样，我们经常关注 alpha 模型，以便在将系统投入生产之前生成最佳的回溯测试夏普比率。众所周知，数据，或者更确切地说是信息，在实际程序或 alpha 模型的成功中扮演着关键的角色。没有数据或信息，它只是未来的一个原型。

一个证券主数据库就像一个算法交易策略和执行引擎一样好。这项服务帮助我们获得、储存、清洗和出口它。此外，迈克尔霍尔斯-摩尔(Michael Halls-Moore)表示，证券主数据是一个全组织范围的数据库，存储各种资产类别的各种金融工具的基本面、定价和交易数据。它以一致的方式提供对这些信息的访问，供风险管理、清算/结算和自营交易等其他部门使用。

HFT 公司通常考虑的一些工具如下:

  • 股票
  • 股权期权
  • 指数
  • 外汇
  • 利率
  • 期货
  • 商品
  • 债券-政府和企业
  • 衍生品-上限、下限、互换

此外，Halls-Moore 指出，证券主数据库通常由开发人员和数据专家组成的团队来确保金融机构内的高可用性。

使用证券大师的原因(扩展)

风险管理

  • 准确评估风险
  • 优化信贷政策
  • 降低运营风险

交易执行

  • 减少交易失败
  • 降低执行成本
  • 减少资本支出

法规遵循

  • 类似于风险管理

客户体验

  • 提高客户满意度
  • 提高员工生产力
  • 自动启动客户端

使用的数据集

股票的 EOD 数据很容易获得。有许多服务通过网络可用的 API 提供免费访问:

  • 雅虎财经
  • 谷歌金融
  • QuantQuote(仅 S&P500 EOD 数据)
  • EODData(需要注册)
  • Quandl

手动下载单个证券的历史数据很简单，但如果每天需要下载许多股票，就会变得非常耗时。因此，我们的证券大师的一个重要组成部分将是自动更新数据集。

存储数据的方法

存储数据有多种方法，下面将重点介绍这些方法。只是要注意，这些都是各有利弊的。

平面文件存储

平面文件通常使用逗号分隔变量(CSV)格式，这种格式将二维数据矩阵存储为一系列行，列数据通过分隔符(通常是逗号，但也可以是空格，如空格或制表符)分隔。对于谷歌定价数据，每一行都代表 OHLC 基模的一个交易日(即交易期间的开盘价、最高价、最低价和收盘价)。

优势:

  • 简单
  • 能够被大量压缩以供下载

缺点:

  • 性能差
  • 缺乏查询能力

文档存储

Java 开发人员最不可能使用的是文档存储。人们会发现存在大量的文档存储，它们与 RDBMS 系统(下面讨论)有很大的不同，因为没有表模式的概念。取而代之的是集合和文档，它们分别与表和记录最为相似。

优势:

  • 适合基本数据或元数据

缺点:

  • 不适用于高分辨率价格数据等时间序列

关系数据库管理系统

这些系统是开发人员最喜欢的，当然可以与平面文件结合使用。顾名思义，这个系统将数据相互关联。它能够通过每个数据表与下一个数据表之间的关系，几乎以一种对象的形式来表示金融工具。对于那些喜欢面向对象语言的人来说，有些技术，比如 Hibernate，允许他们在从可能选择的数据源中提取数据后，通过文档存储将数据映射到某个表中。这已经使用了所有三种存储数据方法的组合。

优势

  • 安装简单
  • 独立于平台
  • 易于查询和集成
  • 性能优化

缺点

  • 定制的复杂性
  • 由于大量存储过程等原因，难以获得更高的性能。

历史数据结构

为了简单起见，以对象形式存储/表示数据更安全。这使得数据库映射变得容易，因为我们已经看到了使用关系数据库的好处。这使我们能够分离数据的不同部分，并使用特定的键和标准将它们重新组合在一起。

Halls-Moore 重点介绍的对象如下:

  • 交易所 -数据的最终原始来源
  • 供应商 -从以下来源获得的特定数据点
  • 工具/代码 -股票或指数的代码/符号，以及基础公司或基金的公司信息。
  • 价格 -特定证券在特定日期的实际价格。
  • 公司行动 -调整定价数据所需的所有股票分割或股息调整的列表(这可能导致一个或多个表格)。
  • 国定假日 -为了避免将交易假日误归类为缺失数据错误，存储国定假日和交叉引用会很有用。

还建议将多个供应商来源结合起来以确保准确性，因为他们使用不同的方法来解析 tickers。这就把我们带到了下一个话题，数据完整性、评估、标准化和准确性。

数据完整性、标准化和准确性

历史定价数据容易出现各种错误。这些错误中的许多依赖于人工判断来决定如何进行。当然，通过适度使用数据分析工具来自动通知此类错误是可能的，但这种解决方案很难实现自动化。例如，霍尔斯-摩尔指出，一个人应该根据使用多少标准差以及在什么样的回望期内选择被告知峰值的阈值。他进一步指出，太高的标准差会错过一些峰值，但太低和许多不寻常的新闻公告会导致假阳性。据我们所知，这些会对您的夏普比率结果产生重大影响。因此，处理这些问题时应格外小心。

以下是 Halls-Moore 强调的数据供应商可能出现的常见错误类型:

  • 公司行为-对股票分割和股息调整的错误处理。人们必须绝对肯定这些公式已经被正确地执行了。
  • 峰值——定价点大大超过一定的历史波动水平。这里必须小心，因为这些尖峰确实会发生——参见 5 月份的闪电崩盘，这是一个可怕的例子。当股票分割发生时，没有考虑股票分割也可能导致峰值。尖峰过滤-脚本用于通知交易者这种情况。
  • 无 OHLC 汇总的 OHLC 数据，如来自雅虎/谷歌的数据，特别容易出现“坏分笔成交点汇总”的情况，即较小的交易所处理的小交易远远高于当天的“主要”交易所价格，从而导致汇总后的最大值/最小值过度膨胀。这与其说是一个“错误”，不如说是一个需要警惕的问题。
  • 丢失数据-丢失数据可能是由于在特定时间段内缺少交易(常见于流动性差的小盘股的秒/分钟解析数据)、交易假期或简单的交易系统错误造成的。缺失的数据可以被填充(即，用先前的值填充)、内插(线性或其他方式)或忽略，这取决于交易系统。

大数据和 GIGO(垃圾输入-垃圾输出)

这个术语是 IBM 技术人员和讲师 George Fuechsel 的发明，根据普林斯顿大学的一篇文章，该术语用于“主要是为了引起对这样一个事实的注意，计算机将毫无疑问地处理最无意义的输入数据(垃圾输入)并产生无意义的输出(垃圾输出)”。Halls-Moore 指出，使用准确、及时的数据来为 alpha 模型提供信息是至关重要的，否则结果往好里说会很差，往坏里说会完全不正确。因此，如果系统投入生产，这将导致巨大的损失。

大数据采用类似矢量的形式，由数量、速度和多样性组成。大数据不同于常规数据，因为数据集非常庞大。因此，它无法通过传统的硬件和软件进行分析，因为传统的硬件和软件只能处理兆字节和千字节的数据，而大数据工具可以用来处理太字节和太字节大小的数据。如果你的算法还考虑到新闻出版物、Twitter 和脸书供稿，就自动化交易而言，大数据的创建速度会非常高。这也类似于人们进入他们系统的各种数据，因为新闻馈送是非结构化的，需要在考虑任何分析之前首先进行分类。

一些机器可读新闻源的供应商，如德意志交易所(Deutsche brse)试图提供 AlphaFlash，它们是:

  • 灵活性:信息必须允许新事件的快速合并。该事件可以是特定的新经济报告，即使该事件可能仅在一个场合具有影响市场的重要意义。
  • 深度和广度:深入挖掘主流市场事件。这是在日常环境中系统地扩展其产品的深度和广度。
  • 计划外事件:这些可能是计划在某一天发布的公告，但没有具体的时间，如季度收益更新或公司依法必须宣布的意外事件，因为它可能对市场产生重大影响。数据由 AlphaFlash 处理并自动提取，然后作为 AlphaFlash 消息发送给客户端。

自动化流程和提高效率

消除系统中的任何低效率并自动化数据的整个生命周期是拥有自动化系统的核心实践之一。从数据的获取、清理到验证、存储、评估和使用，所有部分都需要尽可能高效，因为正如前面提到的，没有数据，尤其是干净的数据，你的软件就像一个原型一样好。

就如何提取数据而言，比如说，从数据存储的位置提取数据，有许多方面可以优化。优化查询(在 RDBMS 的上下文中)有许多考虑因素，我将重点介绍事务管理。事务可以定义为一个不可见的工作单元，它由几个操作组成，为了保持数据的完整性，这些操作要么全部执行，要么都不执行。就像交易执行是一个事务一样，其中涉及的操作也被认为是一个事务。

事务的属性如下:

  • 原子性:这意味着不可分割性；任何不可分割的操作(要么完全完成，要么根本不完成)都被称为原子操作。
  • 一致性:事务必须将持久数据从一种一致状态转换到如果在处理过程中出现故障，数据必须恢复到事务之前的状态。
  • 隔离:事务之间不应该互相影响。进行中的事务尚未提交或回滚，必须与其他事务隔离。虽然几个事务可能同时运行，但对每个事务来说，所有其他事务都应该在它之前或之后完成；所有此类并发事务必须有效地按顺序结束。
  • 持久性:一旦事务成功提交，由该事务提交的状态改变必须是持久的和持久的，不管随后发生的任何失败。

因此，交易可以以两种方式结束；提交(意味着事务的每一步都执行成功)或回滚(保证不会因为前面步骤中的错误而执行任何步骤)。

事务管理的许多其他方面将在后面的文章中讨论，因为它超出了本文的范围。

最后，数据的自动下载可以用像 Windows 中的 bat 文件一样简单的东西来完成，放在任务调度器中，它可以在某一点启动你的软件，并在低频交易系统的交易日结束时下载数据，或者在市场开放时启动你的软件。然后，用户可以根据软件所在的位置激活电子邮件通知或短信通知。这显然会涉及到软件中固有的所有过程。

证券主系统的体系结构

我个人喜欢证券主系统的地方，也是我认为对一个人的交易软件有效工作至关重要的地方，是它采用了许多程序员熟悉的模型-视图-控制器模式。这种模式的基础是程序被分成三个不同的部分，在某种程度上是出于维护和明显的数据完整性的原因。通过拥有一个分层的系统，并将其与 MVC 模式相结合，可以显著降低错误数据读取对整个算法的影响，因为组件是相互隔离的，从而避免了任何混乱。

就证券主系统的高级架构而言，人们期望的组件将是主数据中心，例如，它包含层次结构和市场指数，并且它将被数据源、下游应用程序和一些内部系统所包围。数据源是前面提到的那些，它们位于数据集成层。下游应用程序是位于表示层的 alpha 模型。

根据 Cognizant 20-20 Insights(IT、咨询和业务流程外包服务领域的领导者，也是 S&P500 的一部分)的说法，该架构的一些突出特点如下:

  • 系统中必须存在数据验证规则，以确定数据源的准确性和质量，尤其是来自外部供应商的数据。
  • 安全措施必须能够创建审计跟踪，并防止未经授权的数据更改

结论

如本文所述，建立证券主系统主要是为了风险管理、交易执行、法规遵从性和客户体验。使用的各种数据集可从各种数据供应商如 Google/Yahoo 获得，并且该数据的评估需要符合标准，因为从数据供应商接收的数据容易出现各种错误，这些错误在收集用于分析的数据中没有考虑到。不要忘记从 Twitter、脸书、RSS 源和机器可读新闻源(如德意志交易所的新闻源)接收的大数据。

存储数据的方式也引导我们如何表示从不同供应商收集的数据，因为关系数据库管理系统的优点允许我们以几乎对象的形式存储数据。当然，为了达到更高的效率，RDBMS 也可以与其他存储数据的方法相结合。在效率方面，我们发现事务管理可以帮助我们大大提高速度，因为我们可以使用四个属性，即原子性、一致性、隔离性和持久性来衡量从 RDBMS 中读取的数据的完整性。最后，就整个系统中涉及的不同层次而言，证券主系统的架构起着至关重要的作用。它所遵循的模型-视图-控制器模式消除了一系列的低效率，这些低效率可能会阻碍交易系统以最佳水平运行。

下一步

如果你是一名散户交易者或科技专业人士，想要建立自己的自动化交易平台，今天就开始学习算法交易吧！从基本概念开始，如自动交易架构、市场微观结构、策略回溯测试系统和订单管理系统。

更新

我们注意到一些用户在从雅虎和谷歌金融平台下载市场数据时面临挑战。如果你正在寻找市场数据的替代来源，你可以使用 Quandl 来获得同样的信息。

统计套利的配对动态选择

原文：https://blog.quantinsti.com/selection-pairs-statistical-arbitrage-project-divyant-agarwal/

一个令人难以置信的项目，深入研究并帮助您学习、建模和理解统计套利交易策略的创建和执行。它还有助于你了解如何定量分析建模结果。

这个项目的完整 python 代码也可以在文章末尾以可下载的格式获得。

本文是作者提交的最后一个项目，作为他在 QuantInsti 的算法交易管理课程( EPAT )的一部分。请务必查看我们的项目页面，看看我们的学生正在构建什么。

关于作者

divyant agarwal epat alumni

Divyant Agarwal 是一名金融专业人士，毕业于商业专业。Divyant 正在积极追求他的 CFA，FRM 和 CMT。除此之外，他还完成了算法交易(EPAT)的高管课程，并在机器学习、技术分析和期权交易方面拥有核心竞争力。

目标

这个项目的目标是建立一个统计套利交易策略的模型，并对模型结果进行定量分析。在配对交易中，最大的假设是股票之间的相关性是真实的，在任何背离之后，股票将回到相关关系。

两只股票相关，不代表未来还会继续相关。动机在于这些股票之间的相关性可能不会继续存在，因此配对不应该是固定的，而应该总是基于过去时期的相关性动态选择。

项目策略

想法

这个想法是对在一段时间内保持稳定的资产恢复头寸。

平稳性指的是这样一个事实，如果资产价格没有偏离太多，而是保持在均值附近，那么如果价格比均值低太多，我们可以建立多头头寸；如果价格比均值高太多，我们可以建立空头头寸，预期价格会回到均值。

同样的例子可以在下面看到:

stationarity sbi stocks graph

在上图中，我们可以看到印度国家银行股票 10 年来的每周收盘价。我们可以看到，价格在本质上是稳定的，围绕 240 印度卢比的平均值波动。

股票偏离均值 100 点，然后又回到均值。使用均值回归和平稳性逻辑的交易机会可用于持有该股票，即我们可以在 140 印度卢比附近做多，在 340 印度卢比附近做空。在 Quantra 课程中详细学习均值回归策略。

当在市场上交易时，很难找到自然发生的稳定的价格序列。通常，小麦、玉米和外汇等大宗商品的价格都会出现这种趋势。

然而，该项目的重点是在印度市场进行股票交易，如前所述，很难找到自然发生的稳定价格序列(尤其是股票)。因此，更好的方法是找到倾向于一起移动的股票对，即它们的价差(价格之间的差异)遵循平稳性。

价差和对冲比率

价差的定义是什么？

价差是指两只股票的价格之差。差价计算如下——

*价差=股票 A 的价格–n 股票 B 的对数价格

其中，n 为套期保值比率

对冲比率

套期保值比率是'贝塔系数'，可以通过回归两只股票的收盘价得到。假设，我们有两只股票 A 和 B 最近 10 天的价格

hedge ratio

如果我们在股票 A 和股票 B 之间做线性回归，其中股票 B 是因变量(在 y 轴上)，股票 A 是独立股票(在 x 轴上)，那么变量的贝塔系数就是套期保值比率。

linear regression graph

在上面的例子中，我们可以看到线性回归方程是–

Y = 0.4972 X + 81.44

因此 0.4972 就是套期保值比率。

现在我们有了套期保值比率，我们可以使用下面的公式计算价差

价差=股票 B 价格-对冲比率*股票 A 价格

因此，我们得到下表——

spreads

既然我们已经计算了传播，我们必须检查传播是否稳定。

平稳性检验

假设公式

我们可以使用 ADF 测试来检查价差的平稳性。下面详细讨论一下 ADF 测试。

我们可以使用线性模型从过去的价格数据中描述当前的价格变化

Δp(t) = λp(t − 1) + μ + βt+ α1Δp(t − 1) + ... + αkΔp(t − k) + Єt

其中，
p =乐器价格
δp(t)= p(t)-p(T1)
δp(T1)= p(T1)-p(T2)以此类推
λ=回归系数

在这个检验中，零假设是 λ = 0(不平稳) &替代假设是 λ < 0(平稳)

假设背后的直觉是，如果λ = 0，那么下一个移动不依赖于过去的移动。因此，传播不是静止的。

但如果λ < 0，则意味着下一步棋依赖于过去的值。因此，价差是固定的。

测试临界

临界值可以从χ2(卡方)表值中找到。

常见置信区间的值如下所示

| 概率 | 临界值 |
| 90% | -2.59 |
| 95% | -2.87 |
| 99% | -3.44 |

测试统计

测试统计指的是我们从模型中得到的值。它使用以下公式计算——

DF = (\widehat{\lambda}) / SE (\widehat{\lambda})

where,
DF is Dickey Fueller t-stat
(\widehat{\lambda}) is the predicted coefficient
SE refers to the Standard Error of (\widehat{\lambda})

将测试统计值与测试临界值进行比较，并得出结论

  • 如果检验统计>检验临界–我们拒绝零假设，并得出结论，数据是'平稳的'
  • 如果测试统计数据< test critical – we fail to reject the null hypothesis and conclude that is ‘不稳定

因此，如果价差是稳定的，我们将包括要跟踪的对，否则我们暂时丢弃该对。T3】

代码如下:

posted @ 2024-11-03 04:39  绝不原创的飞龙  阅读(287)  评论(0)    收藏  举报