量化交易—Python基础语法与数据结构

Python是一种高级编程语言，它简单易读并且具有很多强大的功能。下面是Python的基本类型和语法：

基本类型

整数（int）：例如1、2、3；

浮点数（float）：例如3.5、4.2、5.7；

布尔值（bool）：True或False，用于判断真假；

字符串（str）：由单引号或双引号括起来的字符序列，例如"hello"、'world'。

变量

用于存储数据，并可以随时更改；

变量名必须以字母或下划线开头，不能以数字开头；

变量名不能是Python的保留关键字（例如if、else、while等）。

运算符

算术运算符：+、-、*、/、%、**（分别表示加、减、乘、除、取模、幂运算）；

关系运算符：<、>、<=、>=、==、!=（分别表示小于、大于、小于等于、大于等于、等于、不等于）；

逻辑运算符：and、or、not（分别表示与、或、非）。

控制结构

条件语句：if、elif、else（用于判断条件是否成立）；

循环语句：for、while（用于反复执行一段代码）。

例如，以下是一个简单Python程序的代码：

# 定义变量
a = 3 
b = 4.5
c = True
d = "hello"

# 打印变量的类型和值
print(type(a), a)
print(type(b), b)
print(type(c), c)
print(type(d), d)

# 进行数值运算
e = a + b
f = b / a
g = a ** 2

# 打印计算结果
print(e)
print(f)
print(g)

# 判断条件
if a > b:
    print("a > b")
elif a < b:
    print("a < b")
else:
    print("a = b")

# 循环语句
for i in range(5):
    print(i)

i = 0
while i < 5:
    print(i)
    i += 1

输出结果：

<class 'int'> 3
<class 'float'> 4.5
<class 'bool'> True
<class 'str'> hello
7.5
1.5
9
a < b
0
1
2
3
4
0
1
2
3
4

字符串

在Python中，字符串是一种数据类型，表示由一个或多个字符组成的不可变的序列。字符串可以使用单引号、双引号或三引号（单引号或双引号）括起来。例如：

# 字符串定义示例
str1 = 'Hello, World!'
str2 = "Python is fun."
str3 = """This is a multiline 
string."""

Python提供了许多内置的字符串方法，例如split()、join()、strip()等，这些方法可以方便地对字符串进行操作和处理。 除此之外，还可以使用格式化字符串来将变量值插入到字符串中，常见的格式化方法包括使用%、.format()和f-字符串等。
容器

在Python中，容器是一种可以装载多个数据元素的对象。Python提供了许多种不同类型的容器对象，常见的包括字符串、列表、元组、字典、集合等。下面是一些示例代码，演示如何创建并使用不同类型的容器：
下面是一些示例代码，演示如何创建并使用不同类型的容器：

1、列表：

# 创建一个列表
my_list = [1, 2, "hello", 3.5]

# 访问列表中的元素
print(my_list[0])   # 1
print(my_list[2])   # "hello"

# 修改列表中的元素
my_list[3] = 4.2
print(my_list)      # [1, 2, "hello", 4.2]

# 添加元素到列表尾部
my_list.append("world")
print(my_list)      # [1, 2, "hello", 4.2, "world"]

# 在指定位置插入元素
my_list.insert(2, "Python")
print(my_list)      # [1, 2, "Python", "hello", 4.2, "world"]

# 删除列表中的元素
my_list.remove(2)
print(my_list)      # [1, "Python", "hello", 4.2, "world"]

2、元组

# 创建一个元组
my_tuple = (1, 2, "hello", 3.5)

# 访问元组中的元素
print(my_tuple[0])   # 1
print(my_tuple[2])   # "hello"

# 元组不支持修改操作，以下代码会导致错误
my_tuple[3] = 4.2

# 获取元素在元组中的位置
print(my_tuple.index("hello"))   # 2

# 获取元组中某个元素出现的次数
print(my_tuple.count(3.5))       # 1

3、字典

# 创建一个字典
my_dict = {"name": "Tom", "age": 18, "gender": "male"}

# 访问字典中的元素
print(my_dict["name"])      # "Tom"
print(my_dict.get("age"))   # 18

# 修改字典中的元素
my_dict["gender"] = "female"
print(my_dict)              # {"name": "Tom", "age": 18, "gender": "female"}

# 添加新的键值对到字典中
my_dict["grade"] = 90
print(my_dict)              # {"name": "Tom", "age": 18, "gender": "female", "grade": 90}

# 删除字典中的键值对
del my_dict["age"]
print(my_dict)              # {"name": "Tom", "gender": "female", "grade": 90}

4、集合

# 创建一个集合
my_set = {1, 2, "hello", 3.5}

# 访问集合中的元素，注意集合中的元素是无序的，每次输出结果可能不同
print(my_set)                # {1, 2, "hello", 3.5}

# 将列表转换为集合
new_set = set([1, 2, 2, 3, 4, 4])
print(new_set)               # {1, 2, 3, 4}

# 添加元素到集合中
my_set.add("world")
print(my_set)                # {1, 2, "hello", 3.5, "world"}

# 删除集合中的元素
my_set.remove(1)
print(my_set)                # {2, "hello", 3.5, "world"}

循环控制

Python 的循环控制是指可以让程序进行循环执行的结构，常用的循环结构包括 for 循环和 while 循环。下面分别给出这两种循环结构的示例代码：

for 循环：是一种常见的循环结构，通常用于对一个序列或者集合中的每一个元素进行遍历操作，代码示例：

fruits = ["apple", "banana", "orange"]
for fruit in fruits:
    print(fruit)

这段代码中，定义了一个列表 fruits，然后通过 for 循环对列表中的每一个元素进行遍历，并使用 print() 函数打印出来。输出结果为：

apple
banana
orange

while 循环：也是一种常见的循环结构，在满足某个条件时会一直执行，代码示例：

i = 1
while i <= 5:
    print(i)
    i += 1

这段代码中，首先定义一个变量 i 的初始值为 1，然后再 while 循环中设置一个条件，当 i 小于或等于 5 时，就一直执行循环体中的语句。循环体中的语句是打印当前 i 的值，并将 i 的值加 1。输出结果为：

1
2
3
4
5

另外再提一个，for a in array循环表达式：用来遍历一个数据序列，比如列表、元组或字符串，具体使用方法如下：

array = [1, 2, 3, 4, 5]

# 遍历列表
for a in array:
    print(a)      # 输出 1, 2, 3, 4, 5

# 遍历元组
my_tuple = (6, 7, 8, 9, 10)
for a in my_tuple:
    print(a)      # 输出 6, 7, 8, 9, 10

# 遍历字符串
my_str = 'hello'
for a in my_str:
    print(a)      # 输出 h, e, l, l, o

以上代码示例展示了如何使用for a in array循环表达式来遍历不同类型的数据序列。每次循环中，变量a被赋值为序列中的一个元素，程序依次对每个元素执行相同的操作，直到所有元素都被遍历完成。

列表推导式

是Python语言用来从一个可迭代对象中创建列表的一种简介方式。它由一个方括号包裹，包含一条或多条表达式，并可以在其中使用if语句和for循环。例如，以下是使用列表推导式创建一组日期示例：

# 使用列表推导式生成2021年1月的所有日期
dates = [f'2021-01-{d:02}' for d in range(1, 32)]

# 打印结果
print(dates)

输出：

['2021-01-01', '2021-01-02', '2021-01-03', '2021-01-04', '2021-01-05', '2021-01-06', '2021-01-07', '2021-01-08', '2021-01-09', '2021-01-10', '2021-01-11', '2021-01-12', '2021-01-13', '2021-01-14', '2021-01-15', '2021-01-16', '2021-01-17', '2021-01-18', '2021-01-19', '2021-01-20', '2021-01-21', '2021-01-22', '2021-01-23', '2021-01-24', '2021-01-25', '2021-01-26', '2021-01-27', '2021-01-28', '2021-01-29', '2021-01-30', '2021-01-31']

上面的代码中，使用了for循环来遍历1到31的数字，并结合f字符串格式化来生成日期字符串，最后使用列表推导式构建了一个包含所有日期的列表。

为了对应交易日期与收盘价格，使用tuple元组来封装上面结构，zip同时迭代多个序列，每次分别从一个序列中取一个元素，一旦其中某个序列到达结尾，则迭代宣告结束。那么我们可以将每个日期和收盘价格封装为一个元组，然后使用zip()函数同时迭代这两个序列，代码示例：

dates = ('2021-01-01', '2021-01-02', '2021-01-03')
prices = (128.8, 131.1, 129.5)

data = zip(dates, prices)
for d, p in data:
    print(d, p)

输出结果为：

2021-01-01 128.8
2021-01-02 131.1
2021-01-03 129.5

这样我们就可以在每个迭代中同时取出一个日期和一个收盘价格，一一对应地处理它们，而且在任何一个序列到达结尾时都会自动结束迭代。同时，我们也可以通过data对象直接遍历所有元组，在每个迭代中处理每个日期和其对应的收盘价格。另外还可以使用namedtuple来改进代码，使得元组中的元素具有更明确的含义和方便的访问方式。例如：

from collections import namedtuple

Stock = namedtuple('Stock', ['date', 'price'])

dates = ('2021-01-01', '2021-01-02', '2021-01-03')
prices = (128.8, 131.1, 129.5)

stocks = [Stock(date, price) for date, price in zip(dates, prices)]

for stock in stocks:
    print(stock.date, stock.price)

在这个例子中，我们使用namedtuple创建了一个名为Stock的类，并指定其属性为'date'和'price'，这可以使得元组中的元素具有更清晰的含义。然后我们创建了一个包含namedtuple元素的列表，并使用for循环来遍历每个namedtuple。这种方式使代码更具可读性，同时也更便于后续的数据操作。运行上述代码的输出结果是：

2021-01-01 128.8
2021-01-02 131.1
2021-01-03 129.5

字典推导式（dictionary comprehension）
是一种用来快速创建新字典的语法结构。可以使用一种基于现有字典元素或其他可遍历对象的简洁方式来生成新的字典。以下是使用字典推导式改进上面的代码：

from collections import namedtuple
Stock = namedtuple('Stock', ['date', 'price'])
dates = ('2021-01-01', '2021-01-02', '2021-01-03')
prices = (128.8, 131.1, 129.5)
stocks = {date: price for date, price in zip(dates, prices)}
stocks = {date: Stock(date, price) for date, price in stocks.items()}
for stock in stocks.values():
    print(stock.date, stock.price)

在改进后的代码中，将 namedtumple 对象用字典类型来保存，使用字典推导式先生成一组键值对（日期和价格）的字典。然后再用另一条字典推导式构建 namedtumple 对象，最后可以直接遍历字典的值以获取键值对的数据。

有序字典（OrderedDict）

Python 标准库中的 collections 模块提供了一个名为 OrderedDict 的有序字典类型。与普通字典不同，OrderedDict 记录了元素添加的顺序，因此可以在迭代时保持这个顺序，并支持一些有序字典专属的方法（如 popitem(last=True) 可以移除最后添加的元素）。

可以使用 collections 模块中的 OrderedDict 类型来对上面的代码进行改进：

from collections import OrderedDict, namedtuple

Stock = namedtuple('Stock', ['date', 'price'])

dates = ('2021-01-01', '2021-01-02', '2021-01-03')
prices = (128.8, 131.1, 129.5)
stocks = {date: price for date, price in zip(dates, prices)}
stocks = OrderedDict((date, Stock(date, price)) for date, price in stocks.items())

for stock in stocks.values():
    print(stock.date, stock.price)

将 stocks 字典转化为了 OrderedDict 实例。与普通字典不同，OrderedDict 会记住元素添加的顺序并在迭代时保持这个顺序，输出结果可以保证有序。

以上是对Python的基础语法与数据结构做了一个说明，下一期我们将继续对Python函数进行讲解。