在这一部分，我们介绍Python最基础的语法知识。尽管网上关于Python的入门教程浩如烟海，在这一节我们只介绍最基本和最常见的语法。

数据结构和序列

Python为我们定义好了一些数据结构，可以理解为有特定功能的数据组织方式，这些功能为我们使用Python处理数据提供了极大的便利，很多基本的功能不需要我们再动手实现一遍。

2.1 元组(tuple)

2.1.1 元组的定义

元组是一个固定长度，不可改变的Python序列。元组中包含了一系列的元素。创建元组的最简单方式，是用逗号分隔一列值：

a = 1, 2, 3
print(a)

a = (1, 2, 3)  # 等价的定义形式
print(a)

输出为：

(1, 2, 3)
(1, 2, 3)

只有一个元素或者没有元素的情况：

a = 1,  # 此时a是一个元组
print(a)
print(type(a))

a = 1  # 此时a是一个整数
print(a)
print(type(a))

a = ()  # 我们甚至可以定义一个空的元组
print(a)
print(len(a))  # 我们用len函数来查看元组的元素个数

输出为：

(1,)
<class 'tuple'>
1
<class 'int'>
()
0

元组中的元素也可以是一个元组。这些元素也不要求是相同的类型。

a = 1, 'string', 0.5  # 这是一个由整数、字符串、浮点数“混搭”成的元组
print(a)

a = (1, 2, 3), (4, 5)  # 这是一个由元组组成的元组
print(a)

输出为：

(1, 'string', 0.5)
((1, 2, 3), (4, 5))

我们也可以用tuple函数将其他可以迭代的对象（包括我们前面提到的字符串、range函数产生的整数序列，后面会讲到的列表、迭代器）转成一个元组：

# 由字符串转成元组
a = 'this is a string'
b = tuple(a)
print(b)

# 由range函数输出的整数序列（本质上是后面会讲到的迭代器）转成元组
a = range(10)
b = tuple(a)
print(b)

输出为：

('t', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 's', 't', 'r', 'i', 'n', 'g')
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

我们也可以利用现有的元组产生新的元组，例如将多个元组直接相加：

a = 1, 2, 3
b = 4, 5
c = 6, 7
x = a + b + c
print(x)

print((a, b, c))

输出为：

(1, 2, 3, 4, 5, 6, 7)
((1, 2, 3), (4, 5), (6, 7))

或者将一个现成的元组重复几次，得到新的元组：

a = 1, 2, 3
x = a * 3  # 在这里，一个元组乘以一个整数，相当于这个元组的几个复制串联起来
print(x)

与前面提到的字符串中的切片的概念类似，我们可以用方括号中的下标或者下标的范围获取元组中的具体元素：

a = 1, 2, 3, 4, 5
print(a[0])  # 注意在Python中，下标从0开始计数，因此这里我们取得的是第一个元素

print(a[:2])  # 这里我们取的是前两个元素

print(a[-3:])  # 这里我们取的是最后三个元素

输出为：

1
(1, 2)
(3, 4, 5)

如何理解元组的不可改变?

• 元组的元素个数不可以增加或者减少
• 如果元组的元素是不可变的，例如整数、浮点数、字符串、布尔值变量、None变量，那么这个元素的值也不可以变
• 如果元组的元素是可变的，例如后面会讲到的列表，那么这个元素的值仍然可以进行“原地改变”

a = 1, 1.1, 'string', True, [1, 2]  # 创建一个包含不同数据类型的元组
print(a)

# 下面这些试图改变某一个元素的行为都会导致程序报错
# a[0] = 2
# a[1] = 2.2
# a[2] = 'another string'
# a[3] = False
# a[4] = [1, 2, 3]

# 由于后面会讲到的列表支持“原地改变”，例如添加一个元素到列表中，这种情况不会产生新的对象，
# 因此在元组看来，自己的元素没有发生改变，也就不会报错
a[4].append(3)
print(a)

# 不可改变也并不意味着你不可以对变量a重新赋值
# 你可以把a整体变成一个新的元组，但不能单独操作它的某一个元素
a = 1, 2, 3, 4, 5
print(a)

输出为：

(1, 1.1, 'string', True, [1, 2])
(1, 1.1, 'string', True, [1, 2, 3])
(1, 2, 3, 4, 5)

元组的这种不可改变性质在一些情况下会非常有用，特别是当我们想要避免不小心改变某些数值的情况，我们可以使用元组来表示这些数值。

利用关键词in，我们可以判断某个元素是否出现在元组中：

a = 1, 2, 2, 3, 3, 3
print(1 in a)

输出为：

True

利用元组提供的count函数，我们可以计算元组中某个元素出现的次数：

a = 1, 2, 2, 3, 3, 3
print(a.count(2))

输出为：

2

2.1.2 拆分元组

如果你想将元组赋值给类似元组的变量，Python会试图拆分等号右边的值：

tup = (4, 5, 6)
a, b, c = tup  # 我们将3个数值分别赋值给了三个变量
print(a)
print(b)
print(c)

输出为：

4
5
6

即使含有元组的元组也会被拆分：

tup = 4, 5, (6, 7)
a, b, (c, d) = tup  # 注意格式上的一致
print(a)
print(b)
print(c)
print(d)

输出为：

4
5
6
7

使用拆分元组的技巧，我们可以很方便地交换两个变量的数值：

a = 1
b = 2

# 接下来我们需要交换a和b的数值，使得a等于2，b等于1
# 比较笨、其他编程语言不得不使用的方法
tmp = a  # 创建一个临时变量tmp，保留a的数值
a = b  # 用b的数值更新a
b = tmp  # 用临时变量tmp保留着的数值更新b
print(a)
print(b)

a = 1
b = 2
# Python中有简便的方法，可以实现一样的效果
a, b = b, a
print(a)
print(b)

输出为：

2
1
2
1

拆分元组的技巧也可以用来遍历包含元组的元组。对后面会讲到的列表和迭代器，同样的技巧也适用：

seq = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
for a, b, c in seq:
    print('a = %s, b = %s, c = %s' % (a, b, c))  # 回顾一下我们前面提到的字符串格式化的时候，%后面用到了(),也可以理解为是创建了一个元组
    tup = (a, b, c)
    print('another way: a = %s, b = %s, c = %s' % tup)  #等价的方式

输出为：

a = 1, b = 2, c = 3
another way: a = 1, b = 2, c = 3
a = 4, b = 5, c = 6
another way: a = 4, b = 5, c = 6
a = 7, b = 8, c = 9
another way: a = 7, b = 8, c = 9

Python也有高级的拆分元组功能，例如我们只需要元组的开头几个元素，后面的元素并不一定会用到：

values = 1, 2, 3, 4, 5
a, b, *rest = values  # 我们用*定义一个保存后面剩余元素的变量
print(a)
print(b)
print(rest)

# rest的名称并不重要，许多Python程序会习惯于用下划线命名不需要使用的变量
a, b, *_ = values

输出为：

1
2
[3, 4, 5]

2.2 列表(list)

2.2.1 列表定义与元素操作

与元组对比，列表的长度可变、内容可以被修改。元组和列表的相同点在于：（1）可以容纳Python的任何对象；（2）元素是有序的，每个元素有一个索引值。

我们可以用方括号定义，或用list函数将其他类型的数据变成列表：

a = [1, 1.1, 'string', False]  # 列表同样不要求元素的类型都一样
print(a)

a = 1, 2, 3
b = list(a)  # 我们用list函数将一个元组a变成了列表
print(b)

b[0] = 6  # 与元组不同，我们可以直接修改列表中的元素值
print(b)

输出为：

[1, 1.1, 'string', False]
[1, 2, 3]
[6, 2, 3]

列表和元组类似，许多函数中可以交叉使用：

a = [1, 2, 2, 3, 3, 3]
print(1 in a)  # 关键词in判断某个元素是否存在于某个列表中
print(a.count(3))  # count函数用来计算某个元素出现的次数
print(len(a))  # len函数计算列表的长度，即列表中的元素个数

输出为：

True
3
6

由于列表中的元素可变，它比元组多了更多数据相关的操作。我们可以用append函数在列表末尾添加元素：

a = [1, 2, 3]
a.append(4)  #这是一种“原地操作”，我们会直接改变a的值
print(a)

b = a.append(4)  #一种常见错误是试图将append的结果赋值给一个新的变量，在这种情况下，由于append函数默认没有返回值，b的值为None
print(b)

输出为：

[1, 2, 3, 4]
None

insert可以在特定的位置插入元素：

a = [1, 2, 3]
a.insert(0, 4)  # 我们在第一个位置上插入一个4
print(a)

a.insert(10000, 5)  # 需要注意的是，这里的位置建议指明在0和列表长度之间。尽管Python不会报错，这里是一个不好的演示。
print(a)

输出为：

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

insert的逆运算是pop，它移除并返回指定位置的元素：

a = [1, 2, 3]
a.pop(2)
print(a)

a = [1, 2, 3]
# a.pop(1000)  # 与insert不同，在这里，如果我们指定的下标值超过了[负的列表长度,正的列表长度]，Python程序会出错

# 因此，当a的长度为3时，可以接受的下标值为-3到2，这里下标为-3代表的倒数第3个元素，即1；而下标为2代表的正数第3个元素，即3
a.pop(-3)
# a.pop(2)
print(a)

输出为：

[1, 2]
[2, 3]

我们也可以用remove函数去除某个特定的值，remove会从左到右寻找第一次对应这个值的元素，并把它从列表中删去：

a = [1, 2, 3, 4]
a.remove(1)
print(a)

# a.remove(5)  # 如果你试图直接去删除列表中不存在的元素，程序会报错
if 5 in a:  # 可以用in检查这个元素是否存在于列表中，如果存在的话，再进行删除操作
    a.remove(5)

if 5 not in a:  # in关键词也可以和not一起使用
    print('True')

print(a)

输出为：

[2, 3, 4]
True
[2, 3, 4]

当我们想要删除一个列表中的全部元素时，可以使用clear函数：

a = [1, 2, 3]
a.clear()
print(a)

输出为

[]

2.2.2 串联和组合列表

与元组类似，我们可以用加号将两个或多个列表串联起来：

a = [1, 2, 3]
b = [4, 5, 6]
c = [7, 8, 9]
x = a + b + c
print(x)

输出为：

[1, 2, 3, 4, 5, 6, 7, 8, 9]

如果已经定义了一个列表，用extend函数可以追加多个元素：

a = [1, 2, 3]
b = [4, 5, 6]
c = [7, 8, 9]
a.extend(b)  # 与append类似，extend也是“原地操作”，会直接修改a的值
a.extend(c)
print(a)

输出为：

[1, 2, 3, 4, 5, 6, 7, 8, 9]

如果对列表不小心用了append函数，结果会怎么样呢？

a = [1, 2, 3]
b = [4, 5, 6]
c = [7, 8, 9]
a.append(b)
a.append(c)
print(a)
print(len(a))

输出为：

[1, 2, 3, [4, 5, 6], [7, 8, 9]]
5

通过加法将列表串联的计算量较大，因为要新建一个列表，并且要进行复制操作。用extend追加元素，尤其是到一个大列表中，更为可取。

2.2.3 排序

我们可以用sort函数对一个列表进行“原地排序”：

a = [1, 4, 3, 2, 7, 6]
a.sort()
print(a)

a.sort(reverse=True)  # 可以用参数reverse指定逆序
print(a)

输出为：

[1, 2, 3, 4, 6, 7]
[7, 6, 4, 3, 2, 1]

sort有一些选项，有时会很好用。其中之一是二级排序key，可以用这个key进行排序。例如，我们可以按长度对字符串进行排序：

b = ['test', 'a', 'bc', 'maybe', 'string']
b.