书名：Python期货量化交易实战
ISBN：978-7-115-52696-0
本书由人民邮电出版社发行数字版。版权所有，侵权必究。
您购买的人民邮电出版社电子书仅供您个人使用，未经授权，不得以任何方式复制和传播本书内容。
我们愿意相信读者具有这样的良知和觉悟，与我们共同保护知识产权。
如果购买者有侵权行为，我们可能对该用户实施包括但不限于关闭该帐号等维权措施，并可能追究法律责任。
著 酆士昌 刘承彦
改 编 席松鹤
审 校 王海平
责任编辑 胡俊英
人民邮电出版社出版发行 北京市丰台区成寿寺路11号
邮编 100164 电子邮件 315@ptpress.com.cn
网址 http://www.ptpress.com.cn
读者服务热线：(010)81055410
反盗版热线：(010)81055315
原著书名《Python：期货演算法交易事务121个关键技巧详解》
本书中文繁体版本版权由台湾博硕文化股份有限公司（DrMaster Press Co., Ltd）获作者酆士昌、刘承彦授权独家出版发行，中文简体版本版权由博硕文化股份有限公司（DrMaster Press Co., Ltd）获作者同意授权人民邮电出版社有限公司独家出版发行。
如今，要想在企业和投资金融领域保持竞争力，只是精通电子表格和计算器已经远远不够，传统工具和数据集已经无法满足我们的需要。本书将用Python编程来解决期货量化交易的问题，并通过110多个技巧介绍实际的解决方案。
本书基于台湾期货交易所的案例进行讲解，从数据分析的角度切入，以技巧的形式深入数据背后，让读者从基本的期货交易规则开始，了解相关的技术指标，并能够熟练使用Python编程走上量化交易之路。
本书既适合期货领域的从业人员学习，也适合想进入金融领域的程序员参考。
Python是一种面向对象的解释型语言，具备优异的运算能力与执行性能，以及多样的扩展类库，是编写量化交易程序常用的语言之一。由于操作简单、易于上手，Python已成为程序交易切入的方便工具。
量化交易将主观交易的想法具体量化，也就是写成明确的规则，并转为程序语言。一般交易者往往无法明确地提供量化的规则，而程序员对于金融交易普遍陌生，无法深入交易的业务领域。再者，多数交易者使用看盘软件，采用规范的图表与统计后的数据，对交易所原始的报价往往不知该如何处理。因此，量化交易是结合金融交易、程序设计与数据分析三大领域的新兴产业，进入的门槛较高。
鉴于此，我们从数据分析的角度切入，以一个个的示例让读者了解概念，并帮助他们照着案例实操，由最基本的期货交易规则开始，逐步切入程序设计来计算技术指标，进而进行历史回测，最后通过下单函数进行程序交易。本书旨在通过案例的逐步演练，降低学习的门槛，带领读者进入程序交易的殿堂。
本书使用Python作为程序开发的语言。书中的内容均可实操，并且搭配下单程序，可连接群益期货进行实盘交易。
最后，由于本人所知有限，虽求尽善尽美，但疏误之处在所难免，恳请读者不吝指正。
酆士昌
本书介绍由Python编写的程序化交易解决方案。程序化交易涉及多个领域的专业技能，单是财经或信息领域已很难熟悉，因此本书提供了一些交易的观念和方法，让读者可以迅速地切入程序化交易实操。
就解释型语言来说，Python拥有出色的运算效率，也有丰富的第三方类库，在许多应用领域都有出色的解决方案，是一款值得大家学习的程序设计语言。
就程序化交易来说，它的优势是能够克服人性的缺点。在交易中，人性的弱点是很难被忽略的，如贪婪、恐惧、陶醉等，这些都是阻碍稳定交易的因素。程序往往可以克服这些缺点，从中找出一套好的交易模型，并且将风险控制在可接受范围内，产生令人满意的交易。此外，程序化交易也能解决投资人花费大量时间追踪盘势的现状，以往每天需要花费数小时盯盘，现在只要确定程序正常运行，就可以稳定地进行交易。
最后，谢谢我的父母，他们总是给我鼓励；感谢各位朋友、亲戚的支持；感谢我的良师兼益友酆士昌，他伴随着我成长，甚至改变了我的人生道路。
刘承彦
本书由异步社区出品，社区（https://www.epubit.com/）为您提供相关资源和后续服务。
本书提供配套资源，请在异步社区本书页面中点击
，跳转到下载界面，按提示进行操作即可。注意：为保证购书读者的权益，该操作会给出相关提示，要求输入提取码进行验证。
作者和编辑尽最大努力来确保书中内容的准确性，但难免会存在疏漏。欢迎您将发现的问题反馈给我们，帮助我们提升图书的质量。
当您发现错误时，请登录异步社区，按书名搜索，进入本书页面，点击“提交勘误”，输入勘误信息，点击“提交”按钮即可。本书的作者和编辑会对您提交的勘误进行审核，确认并接受后，您将获赠异步社区的100积分。积分可用于在异步社区兑换优惠券、样书或奖品。
我们的联系邮箱是contact@epubit.com.cn。
如果您对本书有任何疑问或建议，请您发邮件给我们，并请在邮件标题中注明本书书名，以便我们更高效地做出反馈。
如果您有兴趣出版图书、录制教学视频，或者参与图书翻译、技术审校等工作，可以发邮件给我们；有意出版图书的作者也可以到异步社区在线提交投稿（直接访问www.epubit.com/selfpublish/submission即可）。
如果您是学校、培训机构或企业，想批量购买本书或异步社区出版的其他图书，也可以发邮件给我们。
如果您在网上发现有针对异步社区出品图书的各种形式的盗版行为，包括对图书全部或部分内容的非授权传播，请您将怀疑有侵权行为的链接发邮件给我们。您的这一举动是对作者权益的保护，也是我们持续为您提供有价值的内容的动力之源。
“异步社区”是人民邮电出版社旗下IT专业图书社区，致力于出版精品IT技术图书和相关学习产品，为作译者提供优质出版服务。异步社区创办于2015年8月，提供大量精品IT技术图书和电子书，以及高品质技术文章和视频课程。更多详情请访问异步社区官网https://www.epubit.com。
“异步图书”是由异步社区编辑团队策划出版的精品IT专业图书的品牌，依托于人民邮电出版社近30年的计算机图书出版积累和专业编辑团队，相关图书在封面上印有异步图书的LOGO。异步图书的出版领域包括软件开发、大数据、AI、测试、前端、网络技术等。
异步社区
微信服务号
Python是一款非常流行的程序语言，广泛地应用于各个领域，并与其他语言、数据库或信息队列有良好的交互方式。Python本身是解释型的语言，运行效率非常高。用Python编写交易程序，必须先从基础的语法开始学习。
Python与一般编程语言不同的地方在于，一般编程语言通过括号来定义代码块，而Python是通过缩进来定义代码块。
Python是一款解释型[1]的开源编程语言，并且有完整的函数库。Python的应用领域相当广泛，一般常见的应用都可以用Python解决。基于上述原因，加上运行效率高等优势，Python成为广泛使用的程序语言。
Python的创始人Guido van Rossum一开始为了打发时间而开发了一款脚本语言，当时是以ABC语言为模板的，但ABC语言并不普及（因为它并非开源的程序语言）。为了避免发生类似的问题，Guido van Rossum开发了Python，并且将Python与其他语言（包括C语言）做了完美的结合。
直至今日，Guido van Rossum仍然决定着Python的整体发展。Python可以被简单地定义为脚本语言，就像shell脚本这种Linux平台下的解释型语言一样，但实际上Python已应用于许多大规模的软件开发中，例如Google的搜索引擎。
Python另一个强大的特点在于它的可扩展特性。Python并不是将所有功能都集中在标准库中，它还拥有相当丰富的工具、API以及第三方类库，也可以通过C语言来开发扩展模块。
本技巧将介绍如何在Windows操作系统上安装Python。本书以Python 3.7版本为例介绍其安装过程。
步骤01 在Python官方网站中的Windows下载专区，单击下载“Latest Python 3 Release – Python3.7.3”[2]，如图1-1所示。
图1-1
步骤02 进入下载页面后，选择32位或64位的Python进行下载，如图1-2所示。
图1-2
步骤03 当下载完成后，启动安装程序，选中“Install for all users”单选项，单击“Customize installation”按钮，如图1-3所示。
图1-3
步骤04 设置路径为“C:\Python37”，并单击“Install”按钮，如图1-4所示。
图1-4
步骤05 Python的安装进度界面如图1-5所示。
图1-5
步骤06 安装完成后，单击“Close”按钮，如图1-6所示。
图1-6
步骤07 安装完成后，在安装路径下会有Python启动程序，如图1-7所示。
图1-7
步骤08 在“开始”菜单中，也有Python启动的快捷方式。选择“IDLE(Python 3.7 64-bit)”，如图1-8所示。
图1-8
步骤09 打开IDLE（Python GUI）启动程序，如图1-9所示。
图1-9
在Python GUI与Windows CMD中启动Python的差别在于，Python GUI提供的功能选项较多，因此若通过Python GUI开发，将有更多的选项可供使用。
Python在Windows中提供了Python.exe启动程序，用户可以直接通过该启动程序编写程序代码。下面介绍Python的基本操作。
启动Python有两种方式：双击Python启动程序图标，弹出Python的命令窗口；或者在Windows CMD中执行Python，直接进入Python的命令窗口。
通过双击Python启动程序（或Python GUI）图标，打开Python命令窗口，即可在命令窗口中使用Python，可参考技巧2的介绍。
接着，在Windows CMD中执行Python，进入Python的安装路径，执行过程如下：
C:\Python37>python
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>每次启动Python都要切换目录相当麻烦，所以可以将Python的安装路径设置到默认的环境变量中，这样Python启动程序在任何路径下都可以直接被执行，设置环境变量的详细步骤可以参考技巧4。
退出Python的方式有两种：一种是通过Windows的组合键Ctrl+C直接退出，另外一种是通过exit函数来退出。下面分别介绍这两种方法。
在Python GUI中通过Windows组合键Ctrl+Z来关闭Python：
>>>
^Z
C:\Python37>在Python GUI或Python的命令窗口中通过exit()函数或quit()函数来关闭Python：
>>> exit()
C:\Python37>Python属于解释型的程序设计语言，不需要编译，只需通过Python执行程序翻译给系统执行。执行Python有以下两种方式。
其中，第二种方式又分为两种用法。Python提供了Python、Pythonw两种执行文档，两者的差异在于：Python文档会显示当前程序所应该显示的结果；而Pythonw文档则不会显示出当前程序应该显示的结果，属于无声执行，适用于常驻程序。
这两种方式都通过Windows CMD来执行，但若每次执行都必须切换目录至安装路径则十分麻烦，因此本技巧先介绍设置环境变量的方法。
下面依次介绍两种设置环境变量的方法。
首先，我们要了解设置的是PATH环境变量，可以通过Windows CMD直接设置。
设置方式是通过命令set来进行，每个路径用英文分号“;”区分，然后将Python安装路径加在最后面，命令如下：
set PATH=%PATH%;＂python 安装路径＂设置过程如下：
C:\Python37>set PATH=%PATH%;"C:\Python37"设置完成后，接着运行查询指令“set Path”，若设置成功，则安装路径会出现在整个环境变量的结尾，如下所示：
C:\Python37>set Path
Path=c:\Rtools\bin;c:\Rtools\mingw_32\bin;C:\Windows\system32;C:\Windows;C:\
Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Program Files
(x86)\NVIDIA Corporation\PhysX\Common;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\
System32\Wbem;C:\WINDOWS\System32\WindowsPowerShell\v1.0\;C:\Program Files\R\
R-3.4.1\bin;C:\Users\jack\AppData\Local\Microsoft\WindowsApps; C:\Python37;
PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC步骤01 找到“我的电脑”快捷方式，单击鼠标右键，接着单击“属性”命令，如图1-10所示。
图1-10
步骤02 进入“属性”界面后，选择“高级系统设置”选项，如图1-11所示。
图1-11
步骤03 进入“系统属性”界面后，打开“高级”选项卡，然后单击“环境变量”按钮，如图1-12所示。
图1-12
步骤04 选择“系统变量”中的“Path”选项，单击“编辑”按钮，如图1-13所示。
图1-13
步骤05 在“变量值”右侧框内的字符串末尾加一个英文的分号，再补充“C:\Python37”（见图1-14），并陆续单击“确定”按钮直至设置完成。
图1-14
说明
在本书中的操作说明中，如果出现的提示符号为“>”或“C:\Python37>”，就表示该程序须在命令提示符或PowerShell中执行“python程序.py”；如果出现的提示符号为“>>>”，就表示须在Python命令窗口或Python GUI下执行示例语法。
基本运算包括四则运算和一些简单的数学函数，而常见的数学函数有绝对值、平方与开方、三角函数与指数、对数等。
Python中提供的基本运算有加、减、乘、除，分别为“+”“−”“*”“/”。下面通过简单的操作来进行介绍。
>>> 1 + 2
3
>>> 7 - 4
3
>>> 7 * 3
21
>>> 21 / 3
7.0变量间的运算方式类似，如下所示：
>>> x=3
>>> y=4
>>> x+y
7
>>> x-y
-1整除是Python中比较特别的运算，又称为地板（floor）除法。
下面通过简单的操作来进行介绍：
>>> 3.0/2
1.5
>>> 3.0//2
1.0整除会将计算出来的浮点型（float）结果的小数点后面的部分无条件舍去；若值为整型（int）结果，则无影响。
变量间的运算方式类似，如下所示：
>>> x=14.0
>>> y=3
>>> x/y
4.666666666666667
>>> x//y
4.0Python提供了幂运算，例如x的y次幂可以用语法表示为x**y，示例如下：
>>> 4**3
64使用变量进行幂运算，示例如下：
>>> x=3
>>> y=4
>>> x**y
81在Python中，可以进行取模运算，例如x除以y的余数的表达式为x%y，示例如下：
>>> 300%10
0
>>> 300%11
3
>>> 12%1
0使用变量进行取模运算，如下所示：
>>> x=14
>>> y=3
>>> x%y
2Python提供了random模块，但该模块不在标准函数库中，所以必须在使用相关函数前导入random模块。
下面介绍random模块和几个常用函数的用法。
导入random模块，并随机生成0～99中的任意值：
>>> import random
>>> random.randint(0,99)
95
>>> random.randint(0,99)
47随机生成0～101中2的倍数：
>>> random.randrange(0, 101, 2)
28
>>> random.randrange(0, 101, 2)
78随机生成0~101中3的倍数：
>>> random.randrange(0, 101, 3)
57
>>> random.randrange(0, 101, 3)
75随机生成一个小于1并且大于0的值：
>>> random.random()
0.24863617521706927在Python中，可以通过函数强制转换数值类型，示例如下：
>>> int(3.1) #小数位数转整数位会无条件舍去
3
>>> x=4.2
>>> int(x)
4
>>>
>>> float(3)
3.0
>>> float(3.7) #小数位数转整浮点位数会完整转出
3.7与C语言相比，Python不仅限于整数与浮点数之间的转换，也可以通过字符串转换为数值，示例如下：
>>> x ="1.2"
>>> float(x)
1.2在Python中，可以通过该函数强制转换数值类型，示例如下：
>>> round(4.5654455) #若没有填入位数参数，则初始值为0
5
>>> round(4.5654455,3) #输入位数参数3，则代表四舍五入至小数第3位
4.565
>>> round(4.5654455,4)
4.5654 使用变量进行四舍五入，如下所示：
>>> x=4/3
>>> round(x)
1在Python中，可以通过floor函数取得小于等于一个数的最大整数。由于floor函数在math模块中，因此必须先导入该模块才可以使用，示例如下：
>>> import math
>>> math.floor(4.56778)
4
>>> math.floor(4)
4
>>> math.floor(-3.44556)
-4使用变量进行操作，如下所示：
>>> x=3.45
>>> y=-4.56
>>> math.floor(x)
3
>>> math.floor(y)
-5在Python中，可以通过ceil函数来取得大于等于某个数的最小整数。由于ceil函数在math模块中，因此必须先导入该模块才可以使用，示例如下：
>>> import math
>>> math.ceil(4)
4
>>> math.ceil(4.1)
5
>>> math.ceil(-3)
-3
>>> math.ceil(-3.3)
-3使用变量进行操作，如下所示：
>>> x=3.45
>>> y=-4.56
>>> math.ceil(y)
-4
>>> math.ceil(x)
4在Python中，可以通过sqrt函数来进行开平方运算。由于sqrt函数在math模块中，因此必须先导入该模块才可以使用，示例如下：
>>> import math
>>> math.sqrt(16)
4.0
>>> math.sqrt(81)
9.0使用变量进行操作，如下所示：
>>> x=100
>>> math.sqrt(x)
10.0在Python中，可以通过abs函数来求绝对值，示例如下：
>>> abs(100)
100
>>> abs(-100.0)
100.0使用变量进行操作，如下所示：
>>> x=-1.354523
>>> abs(x)
1.354523在Python中，可以通过exp函数来求ex。由于exp函数在math模块中，因此使用前必须先导入该模块，示例如下：
>>> import math
>>> math.exp(2)
7.38905609893065
>>> math.exp(10)
22026.465794806718在Python中，可以通过log与log10函数来计算对数，其中log是以e为底的对数，log10是以10为底的对数。由于log函数在math模块中，因此必须先导入该模块才可以使用，示例如下：
>>> import math
>>> math.log(4)
1.3862943611198906
>>> math.log(6)
1.791759469228055在Python中，也有三角函数。由于三角函数在math模块中，所以必须先导入该模块才可以使用，示例如下：
>>> import math
>>> math.sin(10)
-0.5440211108893698
>>> math.cos(10)
-0.8390715290764524
>>> math.tan(10)
0.6483608274590866在Python中，可以通过max函数来求一组数中的最大值，示例如下：
>>> max(-1,1,2,3,4,5,6)
6使用变量进行操作，如下所示：
>>> x=(1,2,3,4,5,6,7)
>>> max(x)
7在Python中，可以通过min函数来取得一组数中的最小值，示例如下：
>>> min(-1,1,2,3,4,5,6)
-1使用变量进行操作，如下所示：
>>> x=(1,2,3,4,5,6,7)
>>> min(x)
1本技巧将依次介绍与变量以及矩阵相关的操作。
Python与大多数编程语言相同，可通过“=”进行变量声明，将等号右边的值赋给左边的变量，示例如下：
>>> x
1
>>> x=(1,2,3) #将元组值赋给x变量
>>> x
(1, 2, 3)
>>> x=[1,2,3] #将列表值赋给x变量
>>> x
[1, 2, 3]在Python中，需通过del命令将变量删除，示例如下：
>>> x
[1, 2, 3]
>>> del x
>>> x
TracebacK(most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'x' is not definedPython继承了C语言的方式，也拥有运算赋值的功能，可以有效地减少程序代码的编写，示例如下：
>>> x=1
>>> x
1
>>> x+=1 #等同于x=x+1
>>> x
2
>>> x-=1 #等同于x=x-1
>>> x
1
>>> x*=3 #等同于x=x*3
>>> x
3
>>> x/=3 #等同于x=x/3
>>> x
1.0幂运算赋值示例如下：
>>> x=3
>>> x**=3 #等同于x=x**3
>>> x
27整除运算赋值示例如下：
>>> x
27
>>> x//=4 #等同于x=x//4
>>> x
6在Python中，dir显示变量，globals显示全局变量，locals显示局部变量，示例如下：
>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'random', 'x', 'y']
>>> globals()
{'__builtins__': <module '__builtin__' (built-in)>, 'random': <module 'random'
from 'C:\Program Files\python\lib\random.py'>, '__package__': None, 'x': 14, 'y': 3, '__name__': '__main__', '__doc__': None}
>>> locals()
{'__builtins__': <module '__builtin__' (built-in)>, 'random': <module 'random'
from 'C:\Program Files\python\lib\random.py'>, '__package__': None, 'x': 14, 'y': 3, '__name__': '__main__', '__doc__': None}
在Python中，type函数能够显示出当前变量的类型。变量类型主要分为数字（number）、字符串（string）、列表（list）、元组（tuple）、字典（dictionary）5种。
其中，数字又分为4种。可使用type函数查看几种数据类型，示例如下：
>>> x=1
>>> type(x)
<type 'int'>
>>> x=1.0
>>> type(x)
<type 'float'>
>>> x="123"
>>> type(x)
<type 'str'>
>>> x=[1,2,3]
>>> type(x)
<type 'list'>
>>> x=(1,2,3)
>>> type(x)
<type 'tuple'>
>>> x={}
>>> type(x)
<type 'dict'>在Python中，没有矩阵这种数据类型，但是有元组、列表与字典这3种类型。其中，元组与列表很相似，都是用来存储数据的序列，也都支持多维的序列（矩阵）；唯一不同之处就是元组在定义完成后，是不允许更改其内部值的，而列表可以更改其内部值。字典在对象中加上了索引值。
下面通过一个示例来介绍元组与列表的差异。
>>> x=[1,2,3]
>>> x[2]=4 #列表对象可以被修改
>>> x
[1, 2, 4]
>>> x=(1,2,3)
>>> x[2]=4 #元组对象无法被修改
TracebacK(most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment 下面分别介绍3种对象的应用。
元组定义以后不得更改其内部元素。下面介绍元组的基本用法。
（1）定义元组
元组是用小括号来定义对象的，示例如下：
>>> x=(1,2,3,4,5,6) #定义一维的元组
>>> x
(1, 2, 3, 4, 5, 6)
>>> x=((1,2),(3,4),(5,6)) #定义二维的元组
>>> x
((1, 2), (3, 4), (5, 6))也可以在一行中定义多个变量，示例如下：
>>> x,y = (1,2,3),(3,4,5)
>>> x
(1, 2, 3)
>>> y
(3, 4, 5)（2）删除元组变量
通过del可以删除元组，示例如下：
>>> x=((1,2),(3,4),(5,6))
>>> x
((1, 2), (3, 4), (5, 6))
>>> del x
>>> x
TracebacK(most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined（3）访问元组
在Python元组对象中，索引值都是从0开始的。访问元组的示例如下：
>>> x=((1,2),(3,4),(5,6))
>>> x
((1, 2), (3, 4), (5, 6))
>>> x[0]
(1, 2)
>>> x[0][0]
1（4）元组计算
元组计算是指将元组进行组合或复制。若要进行数值计算，则需取出元组内的值再进行计算，示例如下：
>>> x=(1,2,3)
>>> y=(7,8,9)
>>> x+y #两个元组组合
(1, 2, 3, 7, 8, 9)
>>> x*3 #元组倍数复制
(1, 2, 3, 1, 2, 3, 1, 2, 3)（5）在函数中的应用
元组也可以用于max、min函数中，示例如下：
>>> x
(1, 2, 3)
>>>
>>> max(x)
3
>>> min(x)
1（6）在判断中的应用
Python提供了in指令，用来判断该元素是否在tuple中，示例如下：
>>> x
(1, 2, 3)
>>> 3 in x
True
>>> 4 in x
False（7）在循环中的应用
Python的元组对象可以直接用来进行循环计算。用户可以利用这个特性来编写程序代码，示例如下：
>>> x
(1, 2, 3)
>>> for i in x:
... print (i)
...
1
2
3列表是Python中定义列表的语法。与元组的不同在于，列表可以变更内部元素值。下面介绍list的基本用法。
（1）定义列表
列表是用中括号来定义对象的，示例如下：
>>> x=[1,2,3,4,5,6]
>>> x
[1, 2, 3, 4, 5, 6]
>>> x=[[1,2],[4,5],[7,8]]
>>> x
[[1, 2], [4, 5], [7, 8]]也可以在一行中定义多个列表变量，示例如下：
>>> x,y=[1,2,3],[6,7,8]
>>> x
[1, 2, 3]
>>> y
[6, 7, 8]（2）删除列表变量
通过del可以删除列表，示例如下：
>>> x=[[1,2],[4,5],[7,8]]
>>> x
[[1, 2], [4, 5], [7, 8]]
>>> del x
>>> x
Traceback(most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined（3）访问列表
在Python列表对象中，列表的索引是从0开始的。下面介绍如何访问列表，示例如下：
>>> x
[1, 2, 3]
>>> x[0]
1
>>> x[:2]
[1, 2]
>>> x=[[1,2],[4,5],[7,8]]
>>> x[0][0]
1
>>> x[1][1]
5（4）计算列表
这里所指的计算是将列表组合或复制。若要进行数值计算，则需先取出列表内的值再进行计算，操作如下：
>>> x,y=[1,2,3],[6,7,8]
>>> x+y
[1, 2, 3, 6, 7, 8]
>>> x*3
[1, 2, 3, 1, 2, 3, 1, 2, 3]（5）函数应用
由于可以更改列表的元素，因此可以使用相对较多的函数。
① append函数可以将参数添加到列表的尾部，示例如下：
>>> x=[45,72,65,21,87]
>>> x
[45, 72, 65, 21, 87]
>>> x.append(100)
>>> x
[45, 72, 65, 21, 87, 100]② count函数可以计算该值在列表中的个数，示例如下：
>>> x
[45, 72, 65, 21, 87, 100]
>>> x.count(5)
0
>>> x.count(65)
1③ extend函数可以将多个列表汇总起来，示例如下：
>>> x
[45, 72, 65, 21, 87, 100]
>>>
>>> x.extend([44,55])
>>> x
[45, 72, 65, 21, 87, 100, 44, 55]④ index函数可以获取特定元素在列表当中的位置，示例如下：
>>> x
[45, 72, 65, 21, 87, 100, 44, 55]
>>> x.index(65)
2
>>> x.index(100)
5⑤ remove函数可以删除列表里面的特定元素，示例如下：
>>> x
[1, 2, 3, 4, 5]
>>> x.remove(4)
>>> x
[1, 2, 3, 5]⑥ reverse函数可以将整个列表的内容反转，示例如下：
>>> x
[1, 2, 3, 5]
>>> x.reverse()
>>> x
[5, 3, 2, 1]⑦ sort函数可以将整个列表按照从小到大的顺序排序，示例如下：
>>> x
[5, 3, 2, 1]
>>> x.sort()
>>> x
[1, 2, 3, 5]（6）在判断中的应用
Python提供了in指令，可以判断该元素是否在列表中，示例如下：
>>> x=[1,2,3,4,5,6,7]
>>> 5 in x
True
>>> 8 in x
False（7）在循环中的应用
Python的列表对象可以直接用来进行循环计算。用户可以利用这个特性来编写程序代码，示例如下：
>>> x=[1,2,3,4,5,6,7]
>>> sum=0
>>> for i in x:
... sum+=i #缩进
...
>>> sum
28（8）列表解析式
列表解析式能够通过简短的程序代码，将一个列表转换为另一个列表。简单来说，有点像在取该列表的子集合，但又不全然如此。在列表解析式中还可以进行栈位的判断、计算，实际上可以实现的功能相当多。
从操作上来说，就是通过循环来进行列表的判断和计算，但列表解析式不需要通过换行就可以实现循环。但就功能上来说，还是有某些限制，例如不能在列表解析式中进行嵌套循环。
列表解析式常用于读取文件、数据筛选等。示例如下：
>>> content = [ line for line in open('Futures_20170815_I020.csv')] #读取文件内容[3]
>>> content[1:10]
['8450010,8450009,TXFH7,128,10310,732,732,202,349\n', '8450011,8450010,TXFH7,128,
10309,4,736,206,350\n', '8450011,8450010,TXFH7,128,10309,1,737,207,351\n',
'8450011,8450010,TXFH7,128,10310,1,738,208,352\n', '8450011,8450010,TXFH7,128,
10310,1,739,209,353\n', '8450011,8450010,TXFH7,128,10309,2,741,210,354\n',
'8450011,8450011,TXFH7,128,10309,1,742,211,355\n', '8450013,8450011,TXFH7,128,
10310,1,743,212,356\n', '8450013,8450011,TXFH7,128,10310,1,744,213,357\n']
>>> I020 = [ line.strip('\n').split(",") for line in content][1:]
>>> I020[1:10]
[['8450011', '8450010', 'TXFH7', '128', '10309', '4', '736', '206', '350'],
['8450011', '8450010', 'TXFH7', '128', '10309', '1', '737', '207', '351'],
['8450011', '8450010', 'TXFH7', '128', '10310', '1', '738', '208', '352'],
['8450011', '8450010', 'TXFH7', '128', '10310', '1', '739', '209', '353'],
['8450011', '8450010', 'TXFH7', '128', '10309', '2', '741', '210', '354'],
['8450011', '8450011', 'TXFH7', '128', '10309', '1', '742', '211', '355'],
['8450013', '8450011', 'TXFH7', '128', '10310', '1', '743', '212', '356'],
['8450013', '8450011', 'TXFH7', '128', '10310', '1', '744', '213', '357'],
['8450013', '8450012', 'TXFH7', '129', '10310', '2', '749', '214', '362']]字典是带有索引的列表，在每个值之前都会加上索引，所以大多数操作都会通过索引来进行取值。
（1）定义字典
字典用大括号来定义，示例如下：
>>> x={'one':123,'two':345,'three':567}
>>> x
{'one': 123, 'two': 345, 'three': 567}（2）删除字典变量
用del可以删除字典，示例如下：
>>> x
{'one': 123, 'two': 345, 'three': 567}
>>> del x
>>> x
Traceback(most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined（3）访问字典
基于字典的存储结构只能通过index访问，示例如下：
>>> x={'one':123,'two':345,'three':567}
>>> x
{'one': 123, 'two': 345, 'three': 567}
>>> x['one']
123
>>> x['three']
567
>>> x[0]
Traceback(most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 0（4）函数应用
① len函数可以查看字典对象的长度，示例如下：
>>> x
{'one': 123, 'two': 345, 'three': 567}
>>> len(x)
3② copy函数可以复制相同的字典对象，示例如下：
>>> x.copy()
{ 'one': 123, 'two': 345, 'three': 567}③ clear函数可以清除字典对象，示例如下：
>>> x.clear()
>>> x
{}④ items函数可以将字典转换成list对象，示例如下：
>>> x.items()
dict_items([('one', 123), ('two', 345), ('three', 567)])许多模块并非是Python的基本模块，当程序开发者需要时，可以另外下载扩展应用的模块，如pymysql、pandas。本技巧将介绍如何安装并使用Python的第三方库。
导入模块需要通过import指令进行。下面以导入math模块为例进行说明，执行过程如下：
>>> import math
>>>math是Python的基本模块，所以不用额外安装即可导入。
导入第三方库，如pymysql（Python连接MySQL的模块），在未安装的情况下会发生以下情况：
>>> import pymysql
Traceback(most recent call last):
File "<stdin>", line 1, in <module>
ImportError: No module named pymysql这时需要先安装该模块。在安装模块前，必须先安装Python管理模块的程序“pip”，安装pip后才可以安装Python的模块，概念有点像Ubuntu的APT“Advanced Packaging Tool”，通过它来安装系统的模块。下面介绍如何安装pip。
如果是从官网上下载安装的Python，其中已经包含了pip，不需要另外安装，但要把“C:\Python37\Scripts”加进系统默认路径（环境变量）下，系统默认的设置可参考技巧4。
接着就可以执行pip命令了，要查看是否配置正确，可在CMD中执行pip命令，过程如下：
>pip
Usage:
pip <command> [options]
Commands:
install Install packages.
download Download packages.
uninstall Uninstall packages.
freeze Output installed packages in requirements format.
list List installed packages.
show Show information about installed packages.
checK Verify installed packages have compatible dependencies.
search Search PyPI for packages.
wheel Build wheels from your requirements.
hash Compute hashes of package archives.
completion A helper command used for command completion.
help Show help for commands.若出现命令的参数说明，则表示正确执行了该命令。
接着安装pymysql模块，通过系统管理员启动Windows CMD，执行以下命令：
pip install pymysql执行过程如下：
接着，进入Python命令窗口中，导入pymysql：
>>> import pymysql
>>>若没有出现错误信息，则表示导入成功。
本技巧介绍Python中常用的字符串处理函数。
len函数可用于查询字符串长度，示例如下：
>>> str="i am a cat"
>>> len(str)
10join函数用于将不同元素组合成一个大字符串，示例如下：
>>> seq=" " #tab符号
>>> cc=('1','2','3','4')
>>> seq.join(cc) #Python中通过’\t’来展示tab
'1\t2\t3\t4'strip函数的示例如下：
>>> str.strip()
'i am a cat'
>>> str.strip("a")
' am a cat'
>>> str.strip("at")
' am a c'lstrip函数的示例如下：
>>> str="i am a cat"
>>> str.lstrip("a")
' am a cat'
>>> str.lstrip("at")
' am a cat'rstrip函数的示例如下：
>>> str="i am a cat"
>>> str.rstrip("a")
'i am a cat'
>>> str.rstrip("at")
'i am a c'swapcase函数的示例如下：
>>> str="I am A cat"
>>> str.swapcase()
'i AM a CAT’lower函数用于将英文字母转换成小写形式，upper函数用于将英文字母转换成大写形式，示例如下：
>>> str="I am A cat"
>>> str.lower()
'i am a cat'
>>> str.upper()
'I AM A CAT'max函数用于查看字符串中的最大值，min函数用于查看字符串中的最小值，示例如下：
>>> str="i am a cat"
>>> max(str)
'c'
>>> min(str)
' '用zfill函数补齐15个字符，示例如下：
>>> str='TTT'
>>> str.zfill(15)
'000000000000TTT'下面replace函数的示例是以空白替换H字符：
>>> str='HUJRYEHDGSJKER'
>>> str.replace('H'," ")
' UJRYE DGSJKER'split函数的示例如下：
>>> str='HUJRYEHDGSJKER'
>>> str.split('J')
['HU', 'RYEHDGS', 'KER']下面splitlines函数的示例是以逗号来进行分割：
>>> >>> str="111\n333\n532\n7456\n234\n122"
>>> str.splitlines()
['111', '333', '532', '7456', '234', '122']Python提供了time模块来解决时间处理的问题，本技巧将详细介绍time模块中的函数应用。
若读者要了解Python的时间格式，则可先参考技巧19，再回来了解时间函数的应用。下面介绍time模块中的函数应用。
通过time.time函数可以获取当前的时间秒数（从1970/01/01 00:00开始计算，直至目前的总秒数），示例如下：
>>> import time
>>> time.time()
1505975715.899
>>> time.time()
1505975719.699获取当前时间后，可以与其他时间进行比较，示例如下：
>>> import time
>>> start=time.time()
>>> time.time() –start
8.256999969482422以上结果代表两次执行的时间差为8秒多。
localtime函数的示例如下：
>>> import time
>>> time.localtime()
time.struct_time(tm_year=2017, tm_mon=9, tm_mday=21, tm_hour=14, tm_min=46, tm_sec=
23, tm_wday=3, tm_yday=264, tm_isdst=0)
>>> time.localtime()[1]
9
>>> time.localtime()[3]
14clock函数的示例如下：
>>> import time
>>> time.clock()
2896.8592524024843
>>> time.clock()
3035.481912434893ctime函数可以用于获取当前时间，并且将秒数转换成字符串，示例如下：
>>> import time
>>> time.ctime()
'Fri Sep 22 10:51:54 2017'
>>> time0=time.time()
>>> time.ctime(time0)
'Thu Sep 21 14:54:38 2017'mktime函数可用于时间的格式转换，示例如下：
>>> import time
>>> t = (2017, 2, 17, 17, 3, 38, 1, 48, 0)
>>> time.mktime(t)
1487322218.0
>>> time.mktime(time.localtime())
1505977263.0
>>> time.mktime(time.localtime())
1505977266.0gmtime函数可用于将秒数转换成为时间元组，示例如下：
>>> import time
>>> time.gmtime(time.time())
time.struct_time(tm_year=2017, tm_mon=9, tm_mday=21, tm_hour=7, tm_min=4, tm_sec=
28, tm_wday=3, tm_yday=264, tm_isdst=0)
>>>mktime与gmtime可搭配使用，示例如下：
>>> t = (2017, 2, 17, 17, 3, 38, 1, 48, 0)
>>> time.mktime(t)
1487322218.0
>>> time.gmtime(time.mktime(t))
time.struct_time(tm_year=2017, tm_mon=2, tm_mday=17, tm_hour=9, tm_min=3, tm_sec= 38, tm_wday=4, tm_yday=48, tm_isdst=0)
>>>strftime函数的示例如下：
>>> import time
>>> time0 = (2017, 2, 17, 17, 3, 38, 1, 48, 0)
>>> time0 = time.mktime(time0)
>>> print (time.strftime("%b-%d-%Y %H:%M:%S", time.gmtime(time0)))
Feb-17-2017 09:03:38strptime函数的示例如下：
>>> import time
>>> time.strptime("12:30:25","%H:%M:%S")
time.struct_time(tm_year=1900, tm_mon=1, tm_mday=1, tm_hour=12, tm_min=30, tm_sec=25, tm_wday=0, tm_yday=1, tm_isdst=-1)
>>>sleep是常用的函数。以下示例将展示sleep函数的用法：
>>> import time
>>> time.time()
1505977722.531
>>> time.sleep(3)
>>> time.time()
1505977725.542
>>>Python对文件的控制，设计得相当完善，可以通过open、close、write、read、rename、remove控制文件的打开、关闭、写入、读取、重命名与移除。
Python提供的open内置函数可以直接打开文件，并且如果设置了适当的权限，就可以对文件进行读写。读取及写入在后面的技巧中会讲解。
打开文件的示例如下：
>>> file= open('123.txt','w+')
>>> file.name #读取后，可以查询文件名称
'123.txt'
>>> file.closed #读取后，可以查询是否关闭读取文件
False
>>> file.mode #读取后，可以查询对文件的权限
'w+'open函数能通过简洁的语法将文件内容存入Python的数组中，示例如下：
>>> [ line for line in open('123.txt')]
['123456789']该用法是通过列表的特性直接将文件通过循环存入数组中。
Python提供的close函数可以直接关闭文件，示例如下：
>>> file.name
'123.txt'
>>> file.closed
False
>>> file.close()
>>> file.name
'123.txt'
>>> file.closed
Truewrite函数可以直接对文件进行写入，示例如下：
>>> file= open('123.txt','w+')
>>> file.write("123456789/n")
>>> file.close()read函数可以直接对文件内容进行读取，示例如下：
>>> file= open('123.txt','r')
>>> file.read()
'123456789/n'
>>> file.close()rename函数可以直接修改文件的名称，但需要导入os模块，示例如下：
>>> import os
>>> os.rename('123.txt','456.txt')remove函数可以直接移除文件，但需要导入os模块，示例如下：
>>> import os
>>> os.remove('456.txt')建立数据库的语法如下：
CREATE DATABASE 数据库名称
示例如下：
> CREATE DATABASE sampledatabases;
Query OK, 1 row affected (0.01 sec)
> show databases; #查看是否创建成功
+--------------------+
| Database |
+--------------------+
| information_schema |
| mysql |
| performance_schema |
| sampledatabases |
+--------------------+
4 rows in set (0.00 sec)删除数据库的语法如下：
DROP DATABASE 数据库名称
示例如下：
> DROP DATABASE sampledatabases;
Query OK, 0 rows affected (0.06 sec)
> show databases; #查看是否刪除成功
+--------------------+
| Database |
+--------------------+
| information_schema |
| mysql |
| performance_schema |
+--------------------+
3 rows in set (0.00 sec)创建和删除数据库一般由数据管理者执行。一般的数据库用户没有相关权限，是无法执行创建和删除数据库的。
建立表比建立数据库还要复杂一点，因为建立表必须定义表名、列、数据类型。考虑到每列的实际用途以及需求都会做不同的设计，若是一般的小额整数数值则会用简单的数据类型（如INT），而不同的数据类型都有不同的功能以及不同的占用空间。如果在数据库中每列的数据类型配置得当，就会提高查找数据库的效率。
建立表的语法如下：
CREATE TABLE 表名称（
列名称 数据类型，
列名称 数据类型，
列名称 数据类型
…）;
在列名称和数据类型中间必须加上一个空格。
下面通过示例介绍表的建立，语句如下：
create table student0101(
ID int,
name varchar(10),
height varchar(10),
weight varchar(10));
输出如下：
> create table student0101(
-> ID int,
-> name varchar(10),
-> height varchar(10),
-> weight varchar(10));
Query OK, 0 rows affected (0.58 sec)上面所展示的语句可以新增带有4列的数据表，使用了INT和VARCHAR两种数据类型，INT为数值类型，VARCHAR为可变长度的字符串类型。
查看列类型，执行语句如下：
> describe student0101;
+--------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+--------+-------------+------+-----+---------+-------+
| ID | int(11) | YES | | NULL | |
| name | varchar(10) | YES | | NULL | |
| height | varchar(10) | YES | | NULL | |
| weight | varchar(10) | YES | | NULL | |
+--------+-------------+------+-----+---------+-------+
4 rows in set (0.00 sec)这里通过数据表student（见表1-1）来介绍数据表的操作。
表1-1 student表
| ID |
name |
height |
weight |
|---|---|---|---|
| 102404248 |
jack |
180 |
80 |
| 102404246 |
hizeba |
170 |
90 |
| 102404247 |
panpan |
165 |
50 |
| 102404225 |
zichang |
165 |
65 |
查询是数据库常用的功能之一，由SELECT与FROM组成：SELECT后接要搜寻的列或通配符星号（*），FROM后接要搜寻的数据表。
查找多列时，列与列之间用逗号“,”分隔；当要查找数据表全部的列时，需使用通配符星号（*）。
查询数据的语法如下：
SELECT * FROM 数据表名称;
示例如下：
SELECT * FROM student;
输出如下：
> SELECT * FROM student;
+-----------+---------+--------+--------+
| ID | name | height | weight |
+-----------+---------+--------+--------+
| 102404248 | jack | 180 | 80 |
| 102404246 | hizeba | 170 | 90 |
| 102404247 | panpan | 165 | 50 |
| 102404225 | zichang | 165 | 65 |
+-----------+---------+--------+--------+
4 rows in set (0.00 sec)本技巧是扩展Python数据库的访问应用。从Python中存取MySQL数据库有许多模块，本技巧通过pymysql库来进行介绍。
说明
安装pymysql库可参考技巧8，在此不另外进行介绍。
当安装完成后，需先导入库才可以使用。语法如下：
import pymysql
若要存取数据库，就必须与数据库建立连接。在pymysql库中，必须通过connect函数来建立连接的对象，之后通过连接的对象来对数据库下指令。
下面介绍如何通过pymysql对数据库存取对象，通过数据库进行存取，读者也可以自行建立数据库进行存取。
在pymysql中执行SELECT、INSERT等动作，操作过程大致相同，只要在execute执行语句中输入SQL查询语句即可。下面介绍操作过程。
首先确认数据库中有数据库和使用者后，先建立连接：
conn = pymysql.connect(host='IP地址', port=端口号, user="使用者" ,passwd="密码", db="数据库")
在建立连接后，接着建立游标，接下来的操作，都是由该对象来完成。
cur = conn.cursor()
接着执行查询语句：
cur.execute("SQL查询语句")
将查询结果依序显示出来：
for row in cur:
print(row)
关闭游标：
cur.close()
关闭连接：
conn.close()
本技巧将阐述如何操作Python中的数组，也就是列表对象，毕竟本书是介绍Python的金融案例操作，回测的部分会与大数据相结合，这时就必须要了解如何使用列表。
前面有涉及列表如何使用的简单叙述，这里进一步叙述常用的应用，即存取、分割和合并。
在Python中，列表对象的赋值是通过中括号来进行的。首先介绍简单的用法，即获取单一值，示例如下：
>>> x = [1,2,3,4,5,6,7,8,9]
>>> x[0]
1
>>> x[1]
2
>>> x[-2]
8通过冒号“:”可以获取连续多个值。若一个数组有9个值，可以取1～3个值，也可以取4～9个值，示例如下：
>>> x
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x[:3]
[1, 2, 3]
>>> x[3:]
[4, 5, 6, 7, 8, 9]
>>> x[:-2]
[1, 2, 3, 4, 5, 6, 7]
>>> x[-2:]
[8, 9]还可以获取特定倍数间隔的值。例如，当目前数组有9个值，可以获取2的倍数索引的值，示例如下：
>>> x
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x[::2]
[1, 3, 5, 7, 9]
>>> x[::3]
[1, 4, 7]若要分割字符串，可以参考技巧9的strsplit函数；若要分割列表，可以通过上述方式来将索引值进行分割，但仅局限于索引值，没有办法依照条件来进行分割。例如，在R语言中就提供了subset函数来进行矩阵切割。
Python列表中的数据切割通过循环来进行简易的判断，语法如下：
自定义变量 for 自定义变量 in 特定列表 if 条件判断语句
操作如下：
>>> x
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> [i for i in x if i > 5]
[6, 7, 8, 9]Python中的数组合并就是列表的合并，可以通过“+”运算符进行list相加，也可以通过append进行列表新增，还可以通过extend进行list合并。
（1）通过“+”对列表进行相加，示例如下：
>>> x=[1,2,3,4]
>>> y=[5,6,7,8]
>>> x+y
[1, 2, 3, 4, 5, 6, 7, 8]（2）通过append函数在列表尾部添加新值，示例如下：
>>> x=[45,72,65,21,87]
>>> x
[45, 72, 65, 21, 87]
>>> x.append(100)
>>> x
[45, 72, 65, 21, 87, 100]（3）通过extend函数可以将多个列表整合起来，示例如下：
>>> x
[45, 72, 65, 21, 87, 100]
>>> x.extend([44,55])
>>> x
[45, 72, 65, 21, 87, 100, 44, 55]判断表达式分为逻辑判断表达式和条件判断表达式，下面介绍两者的使用方式。
Python中的逻辑判断表达式如表1-2所示。
表1-2 逻辑判断表达式
| 逻辑判断表达式名称 |
逻辑判断表达式符号 |
|---|---|
| 大于、大于等于 |
>、>= |
| 小于、小于等于 |
<、<= |
| 等于、不等于 |
=、!= |
| 与（and） |
and |
| 或（or） |
or |
下面分别介绍各种逻辑判断表达式。
（1）大于、大于等于
示例如下：
>>> x=10
>>> x>10
False
>>> x>=10
True（2）小于、小于等于
示例如下：
>>> x=10
>>> x False >>> x<=10 True（3）等于、不等于
示例如下：
>>> x=10
>>> y=9
>>> x==y
False
>>> x!=y
True（4）与（and）
示例如下：
>>> x
10
>>> y
9
>>> x==9 and y==9
False
>>> x==10 and y==9
True
>>>（5）或（or）
示例如下：
>>> x
10
>>> y
9
>>> x==9 or y==10
False
>>> x==10 or y==9
True
>>> x==10 or y==1
True
>>> x==9 or y==9
True介绍完逻辑判断表达式后，接着介绍条件判断表达式。条件判断表达式通过判断指定的条件去做接下来的运算。条件判断表达式主要有if else和switch，下面介绍二者的使用方法。
if else的常用用法分为几种，普通的用法是在if后输入条件表达式并用冒号分割：若条件成立，为TRUE，则执行第一个指定操作；若条件不成立，则进行第二个指定操作。示例如下：
>>> x
10
>>> if x==10: #第一个指定动作
... x+=10
... else: #第二个指定动作
... x-=10
...
>>> x
20在Python中，if else的语法如下：
if 判断条件1：
…
elif 判断条件2
…
示例如下：
>>> x
20
>>> if x ==20:
... x+=10
... elif x==10:
... x-=10
...
>>> x
30在Python中，常用的循环有for和while，下面介绍循环的控制语句（break、continue、pass）。
以往许多编程语言都是通过大括号将循环的程序代码括起来的，但在Python中则是通过缩进（ident）来定义循环内的程序代码。
说明
缩进的方式一般是通过Space键或Tab键来完成的。
在for循环控制结构中，基本语法如下：
for 循环变量in向量：
{运算式}
上述基本语法中的循环变量是循环中一个专属的变量，会通过循环来改变值，常用变量名称是i，当然也可以使用o、e等其他变量名称。当循环结束时，循环变量不会继续存在于Python环境中。
循环结构中的运算式可以从简单到复杂，依照每个人的需求来编写运算式，可以是简单的函数、四则运算乃至复杂的运算分析。
在刚开始写循环语句时，必须注意如果在循环中用到新的变量，就必须先声明该变量。通常是变量声明定义在循环外，因为定义在循环内可能会影响运算。
下面通过一个简单的示例来介绍Python循环。在Python中，可以通过逗号分隔对象并且将其运用在循环中，循环变量会通过向量内的每个值去循环。下面将循环变量的值通过print函数显示出来：
>>> for i in 1,2,3,4 :
... print ("No.",i)
...
No. 1
No. 2
No. 3
No. 4for循环通过向量循环的做法不只有上述方法，也可以用列表、元组对象变量作为循环因子。下面定义向量并通过循环显示出来。
>>> x = [1,2,3,4,5,6,7,8,9,10]
>>> for i in x :
... print ("No.",i)
...
No. 1
No. 2
No. 3
No. 4
No. 5
No. 6
No. 7
No. 8
No. 9
No. 10当然，也可以让循环具有不规则性（不是单纯地让数值从1到10），比如显示奇数。
>>> x = [1,2,3,4,5,6,7,8,9,10]
>>> for i in x[::2] :
... print ("No.",i)
...
No. 1
No. 3
No. 5
No. 7
No. 9以上示例都是介绍for循环中循环变量的变化。下面开始介绍循环中的运算式。下面这个循环的功能是将x变量进行10次计算，通过i计算1+2+3+…+10的值为55。
>>> x
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> y
0
>>> for i in x:
... y+=i
... print (y)
...
1
3
6
10
15
21
28
36
45
55下面对上述循环增加一点变化，加入逻辑判断，并且作出处理。x从1到10，但是当i值为7时略过该循环，进行下一次计算，示例如下。
>>> x
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> y
0
>>> for i in x:
... if i == 7:
... continue
... y+=i
... print (y)
...
1
3
6
10
15
21
29
38
48while循环是Python中除了for之外的另一个重要循环，基本原理很简单，就是制定一个判断原则（逻辑表达式），并遵循这个原则来对子语句进行循环。while和for循环的差异在于，while是通过逻辑判断进行循环，for则是通过制定一个有限变量或向量对象来进行循环。
while循环控制结构的基本语法如下：
while 判断表达式:
程序代码
首先，与for一样写出一个简单的循环，了解while循环的架构。
>>> x=0
>>> while x<=7:
... print (x)
... x+=1
...
0
1
2
3
4
5
6
7
>>> x
8while的特性是容易阅读。在上面的示例中，当x的值超过7时就会跳出循环，不再进行任何计算。在使用while循环时，必须小心地指定循环表达式，因为如果指定不好就可能会无限循环。
无限循环的条件表达式结果永远为1（系统辨识为TRUE），使循环无法停止。下面给出无限循环的一个简单示例。
>>> x =0
>>> while 1 :
... print (x)
... x+=1
...
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
......了解到while循环的概念后，就可以进行四则运算了。只要符合判断条件，就会一直重复执行运算，直到不符合为止。示例如下：
>>> x=1
>>> y=0
>>> while x<= 10:
... y+=x
... x+=1
...
>>> y
55在while循环中，可以通过while判断表达式来决定循环，也可以通过break和continue这两个语句来改变while的循环功能。下面介绍while搭配continue的用法。
>>> x=0
>>> while x ... x+=1 ... if x==5 : ... continue ... print(x)
...
1
2
3
4
6
7
8
9
10从上述示例的结果可以看到，当x值为5时跳至下一循环，不显示5。
break语句可以跳出循环，可以依照不同的需求来使用。
break与continue的不同在于，break会直接跳出循环，不再执行下一个循环，而continue是跳出当前循环，并执行下一个循环。
pass与break、continue的不同之处在于，pass没有实际作用，只是用来编写空的循环主体，并不执行任何动作。
[1] 高级语言和低级语言是对计算机而言的名词：低级语言接近机器语言，计算机易懂而人们难学；高级语言则相反，人们容易学习但计算机需要花更多时间理解处理。因此，高级语言容易入门，但处理性能较差。
[2] 本书提供的源码既可以在Python 2.7上运行，也可以在Python 3.7上运行。——译者注
[3] 在读取文件内容时，本示例所引用的csv文件位于C:\Python37，若读者将csv文件保存于其他位置，请在代码中加入csv文件的存储路径。
[4] 本技巧要提前安装MySQL数据库。
