架构狂人

V1

2023/05/04阅读:22主题:橙心

Python基础篇

大家好,我是易安!

Python语言比起C++、Java等主流语言,语法更简洁,也更接近英语,对编程世界的新人还是很友好的,这也是其显著优点。最近总有人问我Python相关的问题,这些问题也偏基础,自古有句话,授人以鱼不如授人以渔,刚好趁五一时间总结了几篇Python的知识点,帮助小伙伴成功入坑Python,将这门工具语言顺利掌握起来。

Python常用数据结构

对于每一门编程语言来说,数据结构都是其根基。了解掌握Python的基本数据结构,对于学好这门语言至关重要。

列表和元组

首先,我们需要弄清楚最基本的概念,什么是列表和元组呢?

实际上,列表和元组,都是 一个可以放置任意数据类型的有序集合

在绝大多数编程语言中,集合的数据类型必须一致。不过,对于Python的列表和元组来说,并无此要求:

l = [1, 2, 'hello''world'# 列表中同时含有int和string类型的元素
l
[1, 2, 'hello''world']

tup = ('jason', 22) # 元组中同时含有int和string类型的元素
tup
('jason', 22)

其次,我们必须掌握它们的区别。

  • 列表是动态的,长度大小不固定,可以随意地增加、删减或者改变元素(mutable)。

  • 而元组是静态的,长度大小固定,无法增加删减或者改变(immutable)。

下面的例子中,我们分别创建了一个列表与元组。你可以看到,对于列表,我们可以很轻松地让其最后一个元素,由4变为40;但是,如果你对元组采取相同的操作,Python 就会报错,原因就是元组是不可变的。

l = [1, 2, 3, 4]
l[3] = 40 # 和很多语言类似,python中索引同样从0开始,l[3]表示访问列表的第四个元素
l
[1, 2, 3, 40]

tup = (1, 2, 3, 4)
tup[3] = 40
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

可是,如果你想对已有的元组做任何"改变",该怎么办呢?那就只能重新开辟一块内存,创建新的元组了。

比如下面的例子,我们想增加一个元素5给元组,实际上就是创建了一个新的元组,然后把原来两个元组的值依次填充进去。

而对于列表来说,由于其是动态的,我们只需简单地在列表末尾,加入对应元素就可以了。如下操作后,会修改原来列表中的元素,而不会创建新的列表。

tup = (1, 2, 3, 4)
new_tup = tup + (5, ) # 创建新的元组new_tup,并依次填充原元组的值
new _tup
(1, 2, 3, 4, 5)

l = [1, 2, 3, 4]
l.append(5) # 添加元素5到原列表的末尾
l
[1, 2, 3, 4, 5]

通过上面的例子,相信你肯定掌握了列表和元组的基本概念。接下来我们来看一些列表和元组的基本操作和注意事项。

首先,和其他语言不同, Python中的列表和元组都支持负数索引,-1表示最后一个元素,-2表示倒数第二个元素,以此类推。

l = [1, 2, 3, 4]
l[-1]
4

tup = (1, 2, 3, 4)
tup[-1]
4

除了基本的初始化,索引外, 列表和元组都支持切片操作

l = [1, 2, 3, 4]
l[1:3] # 返回列表中索引从1到2的子列表
[2, 3]

tup = (1, 2, 3, 4)
tup[1:3] # 返回元组中索引从1到2的子元组
(2, 3)

另外,列表和元组都 可以随意嵌套

l = [[1, 2, 3], [4, 5]] # 列表的每一个元素也是一个列表

tup = ((1, 2, 3), (4, 5, 6)) # 元组的每一个元素也是一个元组

当然,两者也可以通过list()和tuple()函数相互转换:

list((1, 2, 3))
[1, 2, 3]

tuple([1, 2, 3])
(1, 2, 3)

最后,我们来看一些列表和元组常用的内置函数:

l = [3, 2, 3, 7, 8, 1]
l.count(3)
2
l.index(7)
3
l.reverse()
l
[1, 8, 7, 3, 2, 3]
l.sort()
l
[1, 2, 3, 3, 7, 8]

tup = (3, 2, 3, 7, 8, 1)
tup.count(3)
2
tup.index(7)
3
list(reversed(tup))
[1, 8, 7, 3, 2, 3]
sorted(tup)
[1, 2, 3, 3, 7, 8]

这里我简单解释一下这几个函数的含义。

  • count(item)表示统计列表/元组中item出现的次数。

  • index(item)表示返回列表/元组中item第一次出现的索引。

  • list.reverse()和list.sort()分别表示原地倒转列表和排序(注意,元组没有内置的这两个函数)。

  • reversed()和sorted()同样表示对列表/元组进行倒转和排序,reversed()返回一个倒转后的迭代器(上文例子使用list()函数再将其转换为列表);sorted()返回排好序的新列表。

列表和元组存储方式的差异

前面说了,列表和元组最重要的区别就是,列表是动态的、可变的,而元组是静态的、不可变的。这样的差异,势必会影响两者存储方式。我们可以来看下面的例子:

l = [1, 2, 3]
l.__sizeof__()
64
tup = (1, 2, 3)
tup.__sizeof__()
48

你可以看到,对列表和元组,我们放置了相同的元素,但是元组的存储空间,却比列表要少16字节。这是为什么呢?

事实上,由于列表是动态的,所以它需要存储指针,来指向对应的元素(上述例子中,对于int型,8字节)。另外,由于列表可变,所以需要额外存储已经分配的长度大小(8字节),这样才可以实时追踪列表空间的使用情况,当空间不足时,及时分配额外空间。

l = []
l.__sizeof__() // 空列表的存储空间为40字节
40
l.append(1)
l.__sizeof__()
72 // 加入了元素1之后,列表为其分配了可以存储4个元素的空间 (72 - 40)/8 = 4
l.append(2)
l.__sizeof__()
72 // 由于之前分配了空间,所以加入元素2,列表空间不变
l.append(3)
l.__sizeof__()
72 // 同上
l.append(4)
l.__sizeof__()
72 // 同上
l.append(5)
l.__sizeof__()
104 // 加入元素5之后,列表的空间不足,所以又额外分配了可以存储4个元素的空间

上面的例子,大概描述了列表空间分配的过程。我们可以看到,为了减小每次增加/删减操作时空间分配的开销,Python每次分配空间时都会额外多分配一些,这样的机制(over-allocating)保证了其操作的高效性:增加/删除的时间复杂度均为O(1)。

但是对于元组,情况就不同了。元组长度大小固定,元素不可变,所以存储空间固定。

看了前面的分析,你也许会觉得,这样的差异可以忽略不计。但是想象一下,如果列表和元组存储元素的个数是一亿,十亿甚至更大数量级时,你还能忽略这样的差异吗?

列表和元组的性能

通过学习列表和元组存储方式的差异,我们可以得出结论:元组要比列表更加轻量级一些,所以总体上来说,元组的性能速度要略优于列表。

另外,Python会在后台,对静态数据做一些 资源缓存(resource caching)。通常来说,因为垃圾回收机制的存在,如果一些变量不被使用了,Python就会回收它们所占用的内存,返还给操作系统,以便其他变量或其他应用使用。

但是对于一些静态变量,比如元组,如果它不被使用并且占用空间不大时,Python会暂时缓存这部分内存。这样,下次我们再创建同样大小的元组时,Python就可以不用再向操作系统发出请求,去寻找内存,而是可以直接分配之前缓存的内存空间,这样就能大大加快程序的运行速度。

下面的例子,是计算 初始化 一个相同元素的列表和元组分别所需的时间。我们可以看到,元组的初始化速度,要比列表快5倍。

python3 -m timeit 'x=(1,2,3,4,5,6)'
20000000 loops, best of 5: 9.97 nsec per loop
python3 -m timeit 'x=[1,2,3,4,5,6]'
5000000 loops, best of 5: 50.1 nsec per loop

但如果是 索引操作 的话,两者的速度差别非常小,几乎可以忽略不计。

python3 -m timeit -s 'x=[1,2,3,4,5,6]' 'y=x[3]'
10000000 loops, best of 5: 22.2 nsec per loop
python3 -m timeit -s 'x=(1,2,3,4,5,6)' 'y=x[3]'
10000000 loops, best of 5: 21.9 nsec per loop

当然,如果你想要增加、删减或者改变元素,那么列表显然更优。原因你现在肯定知道了,那就是对于元组,你必须得通过新建一个元组来完成。

列表和元组的使用场景

那么列表和元组到底用哪一个呢?根据上面所说的特性,我们具体情况具体分析。

1. 如果存储的数据和数量不变,比如你有一个函数,需要返回的是一个地点的经纬度,然后直接传给前端渲染,那么肯定选用元组更合适。

def get_location():
    .....
    return (longitude, latitude)

2. 如果存储的数据或数量是可变的,比如社交平台上的一个日志功能,是统计一个用户在一周之内看了哪些用户的帖子,那么则用列表更合适。

viewer_owner_id_list = [] # 里面的每个元素记录了这个viewer一周内看过的所有owner的id
records = queryDB(viewer_id) # 索引数据库,拿到某个viewer一周内的日志
for record in records:
    viewer_owner_id_list.append(record.id)

字典和集合

那究竟什么是字典,什么是集合呢?字典是一系列由键(key)和值(value)配对组成的元素的集合,在Python3.7+,字典被确定为有序(注意:在3.6中,字典有序是一个implementation detail,在3.7才正式成为语言特性,因此3.6中无法100%确保其有序性),而3.6之前是无序的,其长度大小可变,元素可以任意地删减和改变。

相比于列表和元组,字典的性能更优,特别是对于查找、添加和删除操作,字典都能在常数时间复杂度内完成。

而集合和字典基本相同,唯一的区别,就是集合没有键和值的配对,是一系列无序的、唯一的元素组合。

首先我们来看字典和集合的创建,通常有下面这几种方式:

d1 = {'name''jason''age': 20, 'gender''male'}
d2 = dict({'name''jason''age': 20, 'gender''male'})
d3 = dict([('name''jason'), ('age', 20), ('gender''male')])
d4 = dict(name='jason', age=20, gender='male')
d1 == d2 == d3 ==d4
True

s1 = {1, 2, 3}
s2 = set([1, 2, 3])
s1 == s2
True

这里注意,Python中字典和集合,无论是键还是值,都可以是混合类型。比如下面这个例子,我创建了一个元素为 1'hello'5.0 的集合:

s = {1, 'hello', 5.0}

再来看元素访问的问题。字典访问可以直接索引键,如果不存在,就会抛出异常:

d = {'name''jason''age': 20}
d['name']
'jason'
d['location']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'location'

也可以使用get(key, default)函数来进行索引。如果键不存在,调用get()函数可以返回一个默认值。比如下面这个示例,返回了 'null'

d = {'name''jason''age': 20}
d.get('name')
'jason'
d.get('location''null')
'null'

说完了字典的访问,我们再来看集合。

首先我要强调的是, 集合并不支持索引操作,因为集合本质上是一个哈希表,和列表不一样。所以,下面这样的操作是错误的,Python会抛出异常:

s = {1, 2, 3}
s[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support indexing

想要判断一个元素在不在字典或集合内,我们可以用value in dict/set 来判断。

s = {1, 2, 3}
in s
True
10 in s
False

d = {'name''jason''age': 20}
'name' in d
True
'location' in d
False

当然,除了创建和访问,字典和集合也同样支持增加、删除、更新等操作。

d = {'name''jason''age': 20}
d['gender'] = 'male' # 增加元素对'gender': 'male'
d['dob'] = '1999-02-01' # 增加元素对'dob': '1999-02-01'
d
{'name''jason''age': 20, 'gender''male''dob''1999-02-01'}
d['dob'] = '1998-01-01' # 更新键'dob'对应的值
d.pop('dob'# 删除键为'dob'的元素对
'1998-01-01'
d
{'name''jason''age': 20, 'gender''male'}

s = {1, 2, 3}
s.add(4) # 增加元素4到集合
s
{1, 2, 3, 4}
s.remove(4) # 从集合中删除元素4
s
{1, 2, 3}

不过要注意,集合的pop()操作是删除集合中最后一个元素,可是集合本身是无序的,你无法知道会删除哪个元素,因此这个操作得谨慎使用。

实际应用中,很多情况下,我们需要对字典或集合进行排序,比如,取出值最大的50对。

对于字典,我们通常会根据键或值,进行升序或降序排序:

d = {'b': 1, 'a': 2, 'c': 10}
d_sorted_by_key = sorted(d.items(), key=lambda x: x[0]) # 根据字典键的升序排序
d_sorted_by_value = sorted(d.items(), key=lambda x: x[1]) # 根据字典值的升序排序
d_sorted_by_key
[('a', 2), ('b', 1), ('c', 10)]
d_sorted_by_value
[('b', 1), ('a', 2), ('c', 10)]

这里返回了一个列表。列表中的每个元素,是由原字典的键和值组成的元组。

而对于集合,其排序和前面讲过的列表、元组很类似,直接调用sorted(set)即可,结果会返回一个排好序的列表。

s = {3, 4, 2, 1}
sorted(s) # 对集合的元素进行升序排序
[1, 2, 3, 4]

字典和集合性能

字典和集合是进行过性能高度优化的数据结构,特别是对于查找、添加和删除操作。那接下来,我们就来看看,它们在具体场景下的性能表现,以及与列表等其他数据结构的对比。

比如电商企业的后台,存储了每件产品的ID、名称和价格。现在的需求是,给定某件商品的ID,我们要找出其价格。

如果我们用列表来存储这些数据结构,并进行查找,相应的代码如下:

def find_product_price(products, product_id):
    for id, price in products:
        if id == product_id:
            return price
    return None

products = [
    (143121312, 100),
    (432314553, 30),
    (32421912367, 150)
]

print('The price of product 432314553 is {}'.format(find_product_price(products, 432314553)))

# 输出
The price of product 432314553 is 30

假设列表有n个元素,而查找的过程要遍历列表,那么时间复杂度就为O(n)。即使我们先对列表进行排序,然后使用二分查找,也会需要O(logn)的时间复杂度,更何况,列表的排序还需要O(nlogn)的时间。

但如果我们用字典来存储这些数据,那么查找就会非常便捷高效,只需O(1)的时间复杂度就可以完成。原因也很简单,刚刚提到过的,字典的内部组成是一张哈希表,你可以直接通过键的哈希值,找到其对应的值。

products = {
  143121312: 100,
  432314553: 30,
  32421912367: 150
}
print('The price of product 432314553 is {}'.format(products[432314553]))

# 输出
The price of product 432314553 is 30

类似的,现在需求变成,要找出这些商品有多少种不同的价格。我们还用同样的方法来比较一下。

如果还是选择使用列表,对应的代码如下,其中,A和B是两层循环。同样假设原始列表有n个元素,那么,在最差情况下,需要O(n^2)的时间复杂度。

# list version
def find_unique_price_using_list(products):
    unique_price_list = []
    for _, price in products: # A
        if price not in unique_price_list: #B
            unique_price_list.append(price)
    return len(unique_price_list)

products = [
    (143121312, 100),
    (432314553, 30),
    (32421912367, 150),
    (937153201, 30)
]
print('number of unique price is: {}'.format(find_unique_price_using_list(products)))

# 输出
number of unique price is: 3

但如果我们选择使用集合这个数据结构,由于集合是高度优化的哈希表,里面元素不能重复,并且其添加和查找操作只需O(1)的复杂度,那么,总的时间复杂度就只有O(n)。

# set version
def find_unique_price_using_set(products):
    unique_price_set = set()
    for _, price in products:
        unique_price_set.add(price)
    return len(unique_price_set)

products = [
    (143121312, 100),
    (432314553, 30),
    (32421912367, 150),
    (937153201, 30)
]
print('number of unique price is: {}'.format(find_unique_price_using_set(products)))

# 输出
number of unique price is: 3

可能你对这些时间复杂度没有直观的认识,我可以举一个实际工作场景中的例子,让你来感受一下。

下面的代码,初始化了含有100,000个元素的产品,并分别计算了使用列表和集合来统计产品价格数量的运行时间:

import time
id = [x for x in range(0, 100000)]
price = [x for x in range(200000, 300000)]
products = list(zip(id, price))

# 计算列表版本的时间
start_using_list = time.perf_counter()
find_unique_price_using_list(products)
end_using_list = time.perf_counter()
print("time elapse using list: {}".format(end_using_list - start_using_list))
## 输出
time elapse using list: 41.61519479751587

# 计算集合版本的时间
start_using_set = time.perf_counter()
find_unique_price_using_set(products)
end_using_set = time.perf_counter()
print("time elapse using set: {}".format(end_using_set - start_using_set))
# 输出
time elapse using set: 0.008238077163696289

你可以看到,仅仅十万的数据量,两者的速度差异就如此之大。事实上,大型企业的后台数据往往有上亿乃至十亿数量级,如果使用了不合适的数据结构,就很容易造成服务器的崩溃,不但影响用户体验,并且会给公司带来巨大的财产损失。

字典和集合的工作原理

我们通过举例以及与列表的对比,看到了字典和集合操作的高效性。不过,字典和集合为什么能够如此高效,特别是查找、插入和删除操作?

这当然和字典、集合内部的数据结构密不可分。不同于其他数据结构,字典和集合的内部结构都是一张哈希表。

  • 对于字典而言,这张表存储了哈希值(hash)、键和值这3个元素。

  • 而对集合来说,区别就是哈希表内没有键和值的配对,只有单一的元素了。

我们来看,老版本Python的哈希表结构如下所示:

--+-------------------------------+
  | 哈希值(hash)  键(key)  值(value)
--+-------------------------------+
0 |    hash0      key0    value0
--+-------------------------------+
1 |    hash1      key1    value1
--+-------------------------------+
2 |    hash2      key2    value2
--+-------------------------------+
. |           ...
__+_______________________________+

不难想象,随着哈希表的扩张,它会变得越来越稀疏。举个例子,比如我有这样一个字典:

{'name''mike''dob''1999-01-01''gender''male'}

那么它会存储为类似下面的形式:

entries = [
['--''--''--']
[-230273521, 'dob''1999-01-01'],
['--''--''--'],
['--''--''--'],
[1231236123, 'name''mike'],
['--''--''--'],
[9371539127, 'gender''male']
]

这样的设计结构显然非常浪费存储空间。为了提高存储空间的利用率,现在的哈希表除了字典本身的结构,会把索引和哈希值、键、值单独分开,也就是下面这样新的结构:

Indices
----------------------------------------------------
None | index | None | None | index | None | index ...
----------------------------------------------------

Entries
--------------------
hash0   key0  value0
---------------------
hash1   key1  value1
---------------------
hash2   key2  value2
---------------------
        ...
---------------------

那么,刚刚的这个例子,在新的哈希表结构下的存储形式,就会变成下面这样:

indices = [None, 1, None, None, 0, None, 2]
entries = [
[1231236123, 'name''mike'],
[-230273521, 'dob''1999-01-01'],
[9371539127, 'gender''male']
]

我们可以很清晰地看到,空间利用率得到很大的提高。

清楚了具体的设计结构,我们接着来看这几个操作的工作原理。

插入操作

每次向字典或集合插入一个元素时,Python会首先计算键的哈希值(hash(key)),再和 mask = PyDicMinSize - 1做与操作,计算这个元素应该插入哈希表的位置index = hash(key) & mask。如果哈希表中此位置是空的,那么这个元素就会被插入其中。

而如果此位置已被占用,Python便会比较两个元素的哈希值和键是否相等。

  • 若两者都相等,则表明这个元素已经存在,如果值不同,则更新值。

  • 若两者中有一个不相等,这种情况我们通常称为哈希冲突(hash collision),意思是两个元素的键不相等,但是哈希值相等。这种情况下,Python便会继续寻找表中空余的位置,直到找到位置为止。

值得一提的是,通常来说,遇到这种情况,最简单的方式是线性寻找,即从这个位置开始,挨个往后寻找空位。当然,Python内部对此进行了优化(这一点无需深入了解,你有兴趣可以查看源码,我就不再赘述),让这个步骤更加高效。

查找操作

和前面的插入操作类似,Python会根据哈希值,找到其应该处于的位置;然后,比较哈希表这个位置中元素的哈希值和键,与需要查找的元素是否相等。如果相等,则直接返回;如果不等,则继续查找,直到找到空位或者抛出异常为止。

删除操作

对于删除操作,Python会暂时对这个位置的元素,赋于一个特殊的值,等到重新调整哈希表的大小时,再将其删除。

不难理解,哈希冲突的发生,往往会降低字典和集合操作的速度。因此,为了保证其高效性,字典和集合内的哈希表,通常会保证其至少留有1/3的剩余空间。随着元素的不停插入,当剩余空间小于1/3时,Python会重新获取更大的内存空间,扩充哈希表。不过,这种情况下,表内所有的元素位置都会被重新排放。

虽然哈希冲突和哈希表大小的调整,都会导致速度减缓,但是这种情况发生的次数极少。所以,平均情况下,这仍能保证插入、查找和删除的时间复杂度为O(1)。

字符串

什么是字符串呢?字符串是由独立字符组成的一个序列,通常包含在单引号( '')双引号( "")或者三引号之中( ''' '''""" """,两者一样),比如下面几种写法。

name = 'jason'
city = 'beijing'
text = "welcome to python world"

这里定义了name、city和text三个变量,都是字符串类型。我们知道,Python中单引号、双引号和三引号的字符串是一模一样的,没有区别,比如下面这个例子中的s1、s2、s3完全一样。

s1 = 'hello'
s2 = "hello"
s3 = """hello"""
s1 == s2 == s3
True

Python同时支持这三种表达方式,很重要的一个原因就是,这样方便你在字符串中,内嵌带引号的字符串。比如:

"I'm a student"

Python的三引号字符串,则主要应用于多行字符串的情境,比如函数的注释等等。

def calculate_similarity(item1, item2):
    """
    Calculate similarity between two items
    Args:
        item1: 1st item
        item2: 2nd item
    Returns:
      similarity score between item1 and item2
    "
""

同时,Python也支持转义字符。所谓的转义字符,就是用反斜杠开头的字符串,来表示一些特定意义的字符。我把常见的的转义字符,总结成了下面这张表格。

为了方便你理解,我举一个例子来说明。

s = 'a\nb\tc'
print(s)
a
b c

这段代码中的 '\n',表示一个字符——换行符; '\t' 也表示一个字符——横向制表符。所以,最后打印出来的输出,就是字符a,换行,字符b,然后制表符,最后打印字符c。不过要注意,虽然最后打印的输出横跨了两行,但是整个字符串s仍然只有5个元素。

len(s)
5

在转义字符的应用中,最常见的就是换行符 '\n' 的使用。比如文件读取,如果我们一行行地读取,那么每一行字符串的末尾,都会包含换行符 '\n'。而最后做数据处理时,我们往往会丢掉每一行的换行符。

字符串的常用操作

讲完了字符串的基本原理,下面我们一起来看看字符串的常用操作。你可以把字符串想象成一个由单个字符组成的数组,所以,Python的字符串同样支持索引,切片和遍历等等操作。

name = 'jason'
name[0]
'j'
name[1:3]
'as'

和其他数据结构,如列表、元组一样,字符串的索引同样从0开始,index=0表示第一个元素(字符),[index:index+2]则表示第index个元素到index+1个元素组成的子字符串。

遍历字符串同样很简单,相当于遍历字符串中的每个字符。

for char in name:
    print(char)
j
a
s
o
n

特别要注意,Python的字符串是不可变的(immutable)。因此,用下面的操作,来改变一个字符串内部的字符是错误的,不允许的。

s = 'hello'
s[0] = 'H'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

Python中字符串的改变,通常只能通过创建新的字符串来完成。比如上述例子中,想把 'hello' 的第一个字符 'h',改为大写的 'H',我们可以采用下面的做法:

s = 'H' + s[1:]
s = s.replace('h''H')

  • 第一种方法,是直接用大写的 'H',通过加号 '+' 操作符,与原字符串切片操作的子字符串拼接而成新的字符串。

  • 第二种方法,是直接扫描原字符串,把小写的 'h' 替换成大写的 'H',得到新的字符串。

你可能了解到,在其他语言中,如Java,有可变的字符串类型,比如StringBuilder,每次添加、改变或删除字符(串),无需创建新的字符串,时间复杂度仅为O(1)。这样就大大提高了程序的运行效率。

但可惜的是,Python中并没有相关的数据类型,我们还是得老老实实创建新的字符串。因此,每次想要改变字符串,往往需要O(n)的时间复杂度,其中,n为新字符串的长度。

你可能注意到了,上述例子的说明中,我用的是“往往”、“通常”这样的字眼,并没有说“一定”。这是为什么呢?显然,随着版本的更新,Python也越来越聪明,性能优化得越来越好了。

这里,我着重讲解一下,使用加法操作符 '+=' 的字符串拼接方法。因为它是一个例外,打破了字符串不可变的特性。

操作方法如下所示:

str1 += str2  # 表示str1 = str1 + str2

我们来看下面这个例子:

s = ''
for n in range(0, 100000):
    s += str(n)

你觉得这个例子的时间复杂度是多少呢?

每次循环,似乎都得创建一个新的字符串;而每次创建一个新的字符串,都需要O(n)的时间复杂度。因此,总的时间复杂度就为O(1) + O(2) + … + O(n) = O(n^2)。这样到底对不对呢?

乍一看,这样分析确实很有道理,但是必须说明,这个结论只适用于老版本的Python了。自从Python2.5开始,每次处理字符串的拼接操作时(str1 += str2),Python首先会检测str1还有没有其他的引用。如果没有的话,就会尝试原地扩充字符串buffer的大小,而不是重新分配一块内存来创建新的字符串并拷贝。这样的话,上述例子中的时间复杂度就仅为O(n)了。

因此,以后你在写程序遇到字符串拼接时,如果使用’+='更方便,就放心地去用吧,不用过分担心效率问题了。

另外,对于字符串拼接问题,除了使用加法操作符,我们还可以使用字符串内置的join函数。string.join(iterable),表示把每个元素都按照指定的格式连接起来。

l = []
for n in range(0, 100000):
    l.append(str(n))
l = ' '.join(l)

由于列表的append操作是O(1)复杂度,字符串同理。因此,这个含有for循环例子的时间复杂度为n*O(1)=O(n)。

接下来,我们看一下字符串的分割函数split()。string.split(separator),表示把字符串按照separator分割成子字符串,并返回一个分割后子字符串组合的列表。它常常应用于对数据的解析处理,比如我们读取了某个文件的路径,想要调用数据库的API,去读取对应的数据,我们通常会写成下面这样:

def query_data(namespace, table):
    """
    given namespace and table, query database to get corresponding
    data
    "
""

path = 'hive://ads/training_table'
namespace = path.split('//')[1].split('/')[0] # 返回'ads'
table = path.split('//')[1].split('/')[1] # 返回 'training_table'
data = query_data(namespace, table)

此外,常见的函数还有:

  • string.strip(str),表示去掉首尾的str字符串;

  • string.lstrip(str),表示只去掉开头的str字符串;

  • string.rstrip(str),表示只去掉尾部的str字符串。

这些在数据的解析处理中同样很常见。比如很多时候,从文件读进来的字符串中,开头和结尾都含有空字符,我们需要去掉它们,就可以用strip()函数:

s = ' my name is jason '
s.strip()
'my name is jason'

当然,Python中字符串还有很多常用操作,比如,string.find(sub, start, end),表示从start到end查找字符串中子字符串sub的位置等等。这里,我只强调了最常用并且容易出错的几个函数,其他内容你可以自行查找相应的文档、范例加以了解,我就不一一赘述了。

字符串的格式化

最后,我们一起来看看字符串的格式化。什么是字符串的格式化呢?

通常,我们使用一个字符串作为模板,模板中会有格式符。这些格式符为后续真实值预留位置,以呈现出真实值应该呈现的格式。字符串的格式化,通常会用在程序的输出、logging等场景。

举一个常见的例子。比如我们有一个任务,给定一个用户的userid,要去数据库中查询该用户的一些信息,并返回。而如果数据库中没有此人的信息,我们通常会记录下来,这样有利于往后的日志分析,或者是线上bug的调试等等。

我们通常会用下面的方法来表示:

print('no data available for person with id: {}, name: {}'.format(id, name))

其中的string.format(),就是所谓的格式化函数;而大括号{}就是所谓的格式符,用来为后面的真实值——变量name预留位置。如果 id = '123'name='jason',那么输出便是:

'no data available for person with id: 123, name: jason'

这样看来,是不是非常简单呢?

不过要注意,string.format()是最新的字符串格式函数与规范。自然,我们还有其他的表示方法,比如在Python之前版本中,字符串格式化通常用%来表示,那么上述的例子,就可以写成下面这样:

print('no data available for person with id: %s, name: %s' % (id, name))

其中%s表示字符串型,%d表示整型等等,这些属于常识,你应该都了解。

当然,现在你写程序时,我还是推荐使用format函数,毕竟这是最新规范,也是官方文档推荐的规范。

也许有人会问,为什么非要使用格式化函数,上述例子用字符串的拼接不也能完成吗?没错,在很多情况下,字符串拼接确实能满足格式化函数的需求。但是使用格式化函数,更加清晰、易读,并且更加规范,不易出错。

语句

上面我们了解了列表、元组、字典、集合和字符串等一系列Python的基本数据类型,紧接着我们来看下编程中另外一个重要的概念,条件循环语句。

“条件与循环”,可谓编程中的基本功。为什么称它为基本功呢?因为它控制着代码的逻辑,可以说是程序的中枢系统。如果把写程序比作盖楼房,那么条件与循环就是楼房的根基,其他所有东西都是在此基础上构建而成。

毫不夸张地说,写一手简洁易读的条件与循环代码,对提高程序整体的质量至关重要。

条件语句

首先,我们一起来看一下Python的条件语句,用法很简单。比如,我想要表示y=|x|这个函数,那么相应的代码便是:

# y = |x|
if x < 0:
    y = -x
else:
    y = x

和其他语言不一样,我们不能在条件语句中加括号,写成下面这样的格式。

if (x < 0)

但需要注意的是,在条件语句的末尾必须加上冒号(:),这是Python特定的语法规范。

由于Python不支持switch语句,因此,当存在多个条件判断时,我们需要用else if来实现,这在Python中的表达是 elif。语法如下:

if condition_1:
    statement_1
elif condition_2:
    statement_2
...
elif condition_i:
    statement_i
else:
    statement_n

整个条件语句是顺序执行的,如果遇到一个条件满足,比如condition_i满足时,在执行完statement_i后,便会退出整个if、elif、else条件语句,而不会继续向下执行。这个语句在工作中很常用,比如下面的这个例子。

实际工作中,我们经常用ID表示一个事物的属性,然后进行条件判断并且输出。比如,在integrity的工作中,通常用0、1、2分别表示一部电影的色情暴力程度。其中,0的程度最高,是red级别;1其次,是yellow级别;2代表没有质量问题,属于green。

如果给定一个ID,要求输出某部电影的质量评级,则代码如下:

if id == 0:
    print('red')
elif id == 1:
    print('yellow')
else:
    print('green')

不过要注意,if语句是可以单独使用的,但elif、else都必须和if成对使用。

另外,在我们进行条件判断时, 不少人喜欢省略判断的条件,比如写成下面这样:

if s: # s is a string
    ...
if l: # l is a list
    ...
if i: # i is an int
    ...
...

关于省略判断条件的常见用法,我大概总结了一下:

不过,切记,在实际写代码时,我们鼓励,除了boolean类型的数据,条件判断最好是显性的。比如,在判断一个整型数是否为0时,我们最好写出判断的条件:

if i != 0:
    ...

而不是只写出变量名:

if i:
    ...

循环语句

讲完了条件语句,我们接着来看循环语句。所谓循环,顾名思义,本质上就是遍历集合中的元素。和其他语言一样,Python中的循环一般通过for循环和while循环实现。

比如,我们有一个列表,需要遍历列表中的所有元素并打印输出,代码如下:

l = [1, 2, 3, 4]
for item in l:
    print(item)
1
2
3
4

你看,是不是很简单呢?

其实,Python中的数据结构只要是可迭代的(iterable),比如列表、集合等等,那么都可以通过下面这种方式遍历:

for item in <iterable>:
    ...

这里需要单独强调一下字典。字典本身只有键是可迭代的,如果我们要遍历它的值或者是键值对,就需要通过其内置的函数values()或者items()实现。其中,values()返回字典的值的集合,items()返回键值对的集合。

d = {'name''jason''dob''2000-01-01''gender''male'}
for k in d: # 遍历字典的键
    print(k)
name
dob
gender

for v in d.values(): # 遍历字典的值
    print(v)
jason
2000-01-01
male

for k, v in d.items(): # 遍历字典的键值对
    print('key: {}, value: {}'.format(k, v))
key: name, value: jason
key: dob, value: 2000-01-01
key: gender, value: male

看到这里你也许会问,有没有办法通过集合中的索引来遍历元素呢?当然可以,其实这种情况在实际工作中还是很常见的,甚至很多时候,我们还得根据索引来做一些条件判断。

我们通常通过range()这个函数,拿到索引,再去遍历访问集合中的元素。比如下面的代码,遍历一个列表中的元素,当索引小于5时,打印输出:

l = [1, 2, 3, 4, 5, 6, 7]
for index in range(0, len(l)):
    if index < 5:
        print(l[index])

1
2
3
4
5

当我们同时需要索引和元素时,还有一种更简洁的方式,那就是通过Python内置的函数enumerate()。用它来遍历集合,不仅返回每个元素,并且还返回其对应的索引,这样一来,上面的例子就可以写成:

l = [1, 2, 3, 4, 5, 6, 7]
for index, item in enumerate(l):
    if index < 5:
        print(item)

1
2
3
4
5

在循环语句中,我们还常常搭配continue和break一起使用。所谓continue,就是让程序跳过当前这层循环,继续执行下面的循环;而break则是指完全跳出所在的整个循环体。在循环中适当加入continue和break,往往能使程序更加简洁、易读。

比如,给定两个字典,分别是产品名称到价格的映射,和产品名称到颜色列表的映射。我们要找出价格小于1000,并且颜色不是红色的所有产品名称和颜色的组合。如果不用continue,代码应该是下面这样的:

# name_price: 产品名称(str)到价格(int)的映射字典
# name_color: 产品名字(str)到颜色(list of str)的映射字典
for name, price in name_price.items():
    if price < 1000:
        if name in name_color:
            for color in name_color[name]:
                if color != 'red':
                    print('name: {}, color: {}'.format(name, color))
        else:
            print('name: {}, color: {}'.format(name, 'None'))

而加入continue后,代码显然清晰了很多:

# name_price: 产品名称(str)到价格(int)的映射字典
# name_color: 产品名字(str)到颜色(list of str)的映射字典
for name, price in name_price.items():
    if price >= 1000:
        continue
    if name not in name_color:
        print('name: {}, color: {}'.format(name, 'None'))
        continue
    for color in name_color[name]:
        if color == 'red':
            continue
        print('name: {}, color: {}'.format(name, color))

我们可以看到,按照第一个版本的写法,从开始一直到打印输出符合条件的产品名称和颜色,共有5层for或者if的嵌套;但第二个版本加入了continue后,只有3层嵌套。

显然,如果代码中出现嵌套里还有嵌套的情况,代码便会变得非常冗余、难读,也不利于后续的调试、修改。因此,我们要尽量避免这种多层嵌套的情况。

前面讲了for循环,对于while循环,原理也是一样的。它表示当condition满足时,一直重复循环内部的操作,直到condition不再满足,就跳出循环体。

while condition:
    ....

很多时候,for循环和while循环可以互相转换,比如要遍历一个列表,我们用while循环同样可以完成:

l = [1, 2, 3, 4]
index = 0
while index < len(l):
    print(l[index])
    index += 1

那么,两者的使用场景又有什么区别呢?

通常来说,如果你只是遍历一个已知的集合,找出满足条件的元素,并进行相应的操作,那么使用for循环更加简洁。但如果你需要在满足某个条件前,不停地重复某些操作,并且没有特定的集合需要去遍历,那么一般则会使用while循环。

比如,某个交互式问答系统,用户输入文字,系统会根据内容做出相应的回答。为了实现这个功能,我们一般会使用while循环,大致代码如下:

while True:
    try:
        text = input('Please enter your questions, enter "q" to exit')
        if text == 'q':
            print('Exit system')
            break
        ...
        ...
        print(response)
    except Exception as err:
        print('Encountered error: {}'.format(err))
        break

同时需要注意的是,for循环和while循环的效率问题。比如下面的while循环:

i = 0
while i < 1000000:
    i += 1

和等价的for循环:

for i in range(0, 1000000):
    pass

究竟哪个效率高呢?

要知道,range()函数是直接由C语言写的,调用它速度非常快。而while循环中的“i += 1”这个操作,得通过Python的解释器间接调用底层的C语言;并且这个简单的操作,又涉及到了对象的创建和删除(因为i是整型,是immutable,i += 1相当于i = new int(i + 1))。所以,显然,for循环的效率更胜一筹。

条件与循环的复用

前面两部分讲了条件与循环的一些基本操作,接下来,我们重点来看它们的进阶操作,让程序变得更简洁高效。

在阅读代码的时候,你应该常常会发现,有很多将条件与循环并做一行的操作,例如:

expression1 if condition else expression2 for item in iterable

将这个表达式分解开来,其实就等同于下面这样的嵌套结构:

for item in iterable:
    if condition:
        expression1
    else:
        expression2

而如果没有else语句,则需要写成:

expression for item in iterable if condition

举个例子,比如我们要绘制y = 2*|x| + 5 的函数图像,给定集合x的数据点,需要计算出y的数据集合,那么只用一行代码,就可以很轻松地解决问题了:

y = [value * 2 + 5 if value > 0 else -value * 2 + 5 for value in x]

再比如我们在处理文件中的字符串时,常常遇到的一个场景:将文件中逐行读取的一个完整语句,按逗号分割单词,去掉首位的空字符,并过滤掉长度小于等于3的单词,最后返回由单词组成的列表。这同样可以简洁地表达成一行:

text = ' Today,  is, Sunday'
text_list = [s.strip() for s in text.split(','if len(s.strip()) > 3]
print(text_list)
['Today''Sunday']

当然,这样的复用并不仅仅局限于一个循环。比如,给定两个列表x、y,要求返回x、y中所有元素对组成的元组,相等情况除外。那么,你也可以很容易表示出来:

[(xx, yy) for xx in x for yy in y if xx != yy]

这样的写法就等价于:

l = []
for xx in x:
    for yy in y:
        if xx != yy:
            l.append((xx, yy))

熟练之后,你会发现这种写法非常方便。当然,如果遇到逻辑很复杂的复用,你可能会觉得写成一行难以理解、容易出错。那种情况下,用正常的形式表达,也不失为一种好的规范和选择。

输入输出

最简单直接的输入来自键盘操作,比如下面这个例子。

name = input('your name:')
gender = input('you are a boy?(y/n)')

###### 输入 ######
your name:Jack
you are a boy?

welcome_str = 'Welcome to the matrix {prefix} {name}.'
welcome_dic = {
    'prefix''Mr.' if gender == 'y' else 'Mrs',
    'name': name
}

print('authorizing...')
print(welcome_str.format(**welcome_dic))

########## 输出 ##########
authorizing...
Welcome to the matrix Mr. Jack.

input() 函数暂停程序运行,同时等待键盘输入;直到回车被按下,函数的参数即为提示语,输入的类型永远是字符串型(str)。注意,初学者在这里很容易犯错,下面的例子我会讲到。print() 函数则接受字符串、数字、字典、列表甚至一些自定义类的输出。

我们再来看下面这个例子。

a = input()
1
b = input()
2

print('a + b = {}'.format(a + b))
########## 输出 ##############
a + b = 12
print('type of a is {}, type of b is {}'.format(type(a), type(b)))
########## 输出 ##############
type of a is <class 'str'>, type of b is <class 'str'>
print('a + b = {}'.format(int(a) + int(b)))
########## 输出 ##############
a + b = 3

这里注意,把 str 强制转换为 int 请用 int(),转为浮点数请用 float()。而在生产环境中使用强制转换时,请记得加上 try except(即错误和异常处理)。

Python 对 int 类型没有最大限制(相比之下, C++ 的 int 最大为 2147483647,超过这个数字会产生溢出),但是对 float 类型依然有精度限制。这些特点,除了在一些算法竞赛中要注意,在生产环境中也要时刻提防,避免因为对边界条件判断不清而造成 bug 甚至 0day(危重安全漏洞)。

我们回望一下币圈。2018年4月23日中午11点30分左右,BEC 代币智能合约被黑客攻击。黑客利用数据溢出的漏洞,攻击与美图合作的公司美链 BEC 的智能合约,成功地向两个地址转出了天量级别的 BEC 代币,导致市场上的海量 BEC 被抛售,该数字货币的价值也几近归零,给 BEC 市场交易带来了毁灭性的打击。

由此可见,虽然输入输出和类型处理事情简单,但我们一定要慎之又慎。毕竟相当比例的安全漏洞,都来自随意的 I/O 处理。

文件输入输出

命令行的输入输出,只是 Python 交互的最基本方式,适用一些简单小程序的交互。而生产级别的 Python 代码,大部分 I/O 则来自于文件、网络、其他进程的消息等等。

接下来,我们来详细分析一个文本文件读写。假设我们有一个文本文件in.txt,内容如下:

I have a dream that my four little children will one day live in a nation where they will not be judged by the color of their skin but by the content of their character. I have a dream today.

I have a dream that one day down in Alabama, with its vicious racists, . . . one day right there in Alabama little black boys and black girls will be able to join hands with little white boys and white girls as sisters and brothers. I have a dream today.

I have a dream that one day every valley shall be exalted, every hill and mountain shall be made low, the rough places will be made plain, and the crooked places will be made straight, and the glory of the Lord shall be revealed, and all flesh shall see it together.

This is our hope. . . With this faith we will be able to hew out of the mountain of despair a stone of hope. With this faith we will be able to transform the jangling discords of our nation into a beautiful symphony of brotherhood. With this faith we will be able to work together, to pray together, to struggle together, to go to jail together, to stand up for freedom together, knowing that we will be free one day. . . .

And when this happens, and when we allow freedom ring, when we let it ring from every village and every hamlet, from every state and every city, we will be able to speed up that day when all of God's children, black men and white men, Jews and Gentiles, Protestants and Catholics, will be able to join hands and sing in the words of the old Negro spiritual: "Free at last! Free at last! Thank God Almighty, we are free at last!"

好,让我们来做一个简单的 NLP(自然语言处理)任务。如果你对此不太了解也没有影响,我会带你一步步完成这个任务。

首先,我们要清楚NLP任务的基本步骤,也就是下面的四步:

  1. 读取文件;

  2. 去除所有标点符号和换行符,并把所有大写变成小写;

  3. 合并相同的词,统计每个词出现的频率,并按照词频从大到小排序;

  4. 将结果按行输出到文件 out.txt。

你可以自己先思考一下,用Python如何解决这个问题。这里,我也给出了我的代码,并附有详细的注释。我们一起来看下这段代码。

import re

# 你不用太关心这个函数
def parse(text):
    # 使用正则表达式去除标点符号和换行符
    text = re.sub(r'[^\w ]'' ', text)

    # 转为小写
    text = text.lower()

    # 生成所有单词的列表
    word_list = text.split(' ')

    # 去除空白单词
    word_list = filter(None, word_list)

    # 生成单词和词频的字典
    word_cnt = {}
    for word in word_list:
        if word not in word_cnt:
            word_cnt[word] = 0
        word_cnt[word] += 1

    # 按照词频排序
    sorted_word_cnt = sorted(word_cnt.items(), key=lambda kv: kv[1], reverse=True)

    return sorted_word_cnt

with open('in.txt''r') as fin:
    text = fin.read()

word_and_freq = parse(text)

with open('out.txt''w') as fout:
    for word, freq in word_and_freq:
        fout.write('{} {}\n'.format(word, freq))

########## 输出(省略较长的中间结果) ##########

and 15
be 13
will 11
to 11
the 10
of 10
a 8
we 8
day 6

...

old 1
negro 1
spiritual 1
thank 1
god 1
almighty 1
are 1

你不用太关心 parse() 函数的具体实现,你只需要知道,它做的事情是把输入的 text 字符串,转化为我们需要的排序后的词频统计。而 sorted_word_cnt 则是一个二元组的列表(list of tuples)。

首先我们需要先了解一下,计算机中文件访问的基础知识。事实上,计算机内核(kernel)对文件的处理相对比较复杂,涉及到内核模式、虚拟文件系统、锁和指针等一系列概念,这些内容我不会深入讲解,我只说一些基础但足够使用的知识。

我们先要用open() 函数拿到文件的指针。其中,第一个参数指定文件位置(相对位置或者绝对位置);第二个参数,如果是 'r' 表示读取,如果是 'w' 则表示写入,当然也可以用 'rw' ,表示读写都要。a 则是一个不太常用(但也很有用)的参数,表示追加(append),这样打开的文件,如果需要写入,会从原始文件的最末尾开始写入。

这里我插一句,在 Facebook 的工作中,代码权限管理非常重要。如果你只需要读取文件,就不要请求写入权限。这样在某种程度上可以降低 bug 对整个系统带来的风险。

好,回到我们的话题。在拿到指针后,我们可以通过 read() 函数,来读取文件的全部内容。代码 text = fin.read() ,即表示把文件所有内容读取到内存中,并赋值给变量 text。这么做自然也是有利有弊:

  • 优点是方便,接下来我们可以很方便地调用 parse 函数进行分析;

  • 缺点是如果文件过大,一次性读取可能造成内存崩溃。

这时,我们可以给 read 指定参数 size ,用来表示读取的最大长度。还可以通过 readline() 函数,每次读取一行,这种做法常用于数据挖掘(Data Mining)中的数据清洗,在写一些小的程序时非常轻便。如果每行之间没有关联,这种做法也可以降低内存的压力。而write() 函数,可以把参数中的字符串输出到文件中,也很容易理解。

这里我需要简单提一下 with 语句(后文会详细讲到)。open() 函数对应于 close() 函数,也就是说,如果你打开了文件,在完成读取任务后,就应该立刻关掉它。而如果你使用了 with 语句,就不需要显式调用 close()。在 with 的语境下任务执行完毕后,close() 函数会被自动调用,代码也简洁很多。

最后需要注意的是,所有 I/O 都应该进行错误处理。因为 I/O 操作可能会有各种各样的情况出现,而一个健壮(robust)的程序,需要能应对各种情况的发生,而不应该崩溃(故意设计的情况除外)。

JSON 序列化实战

最后,我来讲一个和实际应用很贴近的知识点。

JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,它的设计意图是把所有事情都用设计的字符串来表示,这样既方便在互联网上传递信息,也方便人进行阅读(相比一些 binary 的协议)。JSON 在当今互联网中应用非常广泛,也是每一个用 Python程序员应当熟练掌握的技能点。

设想一个情景,你要向交易所购买一定数额的股票。那么,你需要提交股票代码、方向(买入/卖出)、订单类型(市价/限价)、价格(如果是限价单)、数量等一系列参数,而这些数据里,有字符串,有整数,有浮点数,甚至还有布尔型变量,全部混在一起并不方便交易所解包。

那该怎么办呢?

其实,我们要讲的JSON ,正能解决这个场景。你可以把它简单地理解为两种黑箱:

  • 第一种,输入这些杂七杂八的信息,比如Python 字典,输出一个字符串;

  • 第二种,输入这个字符串,可以输出包含原始信息的 Python 字典。

具体代码如下:

import json

params = {
    'symbol''123456',
    'type''limit',
    'price': 123.4,
    'amount': 23
}

params_str = json.dumps(params)

print('after json serialization')
print('type of params_str = {}, params_str = {}'.format(type(params_str), params))

original_params = json.loads(params_str)

print('after json deserialization')
print('type of original_params = {}, original_params = {}'.format(type(original_params), original_params))

########## 输出 ##########

after json serialization
type of params_str = <class 'str'>, params_str = {'symbol''123456''type''limit''price': 123.4, 'amount': 23}
after json deserialization
type of original_params = <class 'dict'>, original_params = {'symbol''123456''type''limit''price': 123.4, 'amount': 23}

其中,

  • json.dumps() 这个函数,接受 Python 的基本数据类型,然后将其序列化为 string;

  • 而json.loads() 这个函数,接受一个合法字符串,然后将其反序列化为 Python 的基本数据类型。

是不是很简单呢?

不过还是那句话,请记得加上错误处理。不然,哪怕只是给 json.loads() 发送了一个非法字符串,而你没有 catch 到,程序就会崩溃了。

到这一步,你可能会想,如果我要输出字符串到文件,或者从文件中读取JSON字符串,又该怎么办呢?

是的,你仍然可以使用上面提到的 open() 和 read()/write() ,先将字符串读取/输出到内存,再进行JSON编码/解码,当然这有点麻烦。

import json

params = {
    'symbol''123456',
    'type''limit',
    'price': 123.4,
    'amount': 23
}

with open('params.json''w') as fout:
    params_str = json.dump(params, fout)

with open('params.json''r') as fin:
    original_params = json.load(fin)

print('after json deserialization')
print('type of original_params = {}, original_params = {}'.format(type(original_params), original_params))

########## 输出 ##########

after json deserialization
type of original_params = <class 'dict'>, original_params = {'symbol''123456''type''limit''price': 123.4, 'amount': 23}

这样,我们就简单清晰地实现了读写 JSON 字符串的过程。当开发一个第三方应用程序时,你可以通过 JSON 将用户的个人配置输出到文件,方便下次程序启动时自动读取。这也是现在普遍运用的成熟做法。

那么 JSON 是唯一的选择吗?显然不是,它只是轻量级应用中最方便的选择之一。据我所知,在 Google,有类似的工具叫做Protocol Buffer,当然,Google 已经完全开源了这个工具,你可以自己了解一下使用方法。

相比于 JSON,它的优点是生成优化后的二进制文件,因此性能更好。但与此同时,生成的二进制序列,是不能直接阅读的。它在 TensorFlow 等很多对性能有要求的系统中都有广泛的应用。

错误与异常

首先要了解,Python中的错误和异常是什么?两者之间又有什么联系和区别呢?

通常来说,程序中的错误至少包括两种,一种是语法错误,另一种则是异常。

所谓语法错误,你应该很清楚,也就是你写的代码不符合编程规范,无法被识别与执行,比如下面这个例子:

if name is not None
    print(name)

If语句漏掉了冒号,不符合Python的语法规范,所以程序就会报错 invalid syntax

而异常则是指程序的语法正确,也可以被执行,但在执行过程中遇到了错误,抛出了异常,比如下面的3个例子:

10 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by zero

order * 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'order' is not defined

1 + [1, 2]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'list'

它们语法完全正确,但显然,我们不能做除法时让分母为0;也不能使用未定义的变量做运算;而让一个整型和一个列表相加也是不可取的。

于是,当程序运行到这些地方时,就抛出了异常,并且终止运行。例子中的 ZeroDivisionError NameErrorTypeError,就是三种常见的异常类型。

当然,Python中还有很多其他异常类型,比如 KeyError 是指字典中的键找不到; FileNotFoundError 是指发送了读取文件的请求,但相应的文件不存在等等,我在此不一一赘述,你可以自行参考 相应文档

如何处理异常

刚刚讲到,如果执行到程序中某处抛出了异常,程序就会被终止并退出。你可能会问,那有没有什么办法可以不终止程序,让其照样运行下去呢?答案当然是肯定的,这也就是我们所说的异常处理,通常使用try和except来解决,比如:

try:
    s = input('please enter two numbers separated by comma: ')
    num1 = int(s.split(',')[0].strip())
    num2 = int(s.split(',')[1].strip())
    ...
except ValueError as err:
    print('Value Error: {}'.format(err))

print('continue')
...

这里默认用户输入以逗号相隔的两个整形数字,将其提取后,做后续的操作(注意input函数会将输入转换为字符串类型)。如果我们输入 a,b,程序便会抛出异常 invalid literal for int() with base 10: 'a',然后跳出try这个block。

由于程序抛出的异常类型是ValueError,和except block所catch的异常类型相匹配,所以except block便会被执行,最终输出 Value Error: invalid literal for int() with base 10: 'a',并打印出 continue

please enter two numbers separated by comma: a,b
Value Error: invalid literal for int() with base 10: 'a'
continue

我们知道,except block只接受与它相匹配的异常类型并执行,如果程序抛出的异常并不匹配,那么程序照样会终止并退出。

所以,还是刚刚这个例子,如果我们只输入 1,程序抛出的异常就是 IndexError: list index out of range,与ValueError不匹配,那么except block就不会被执行,程序便会终止并退出(continue不会被打印)。

please enter two numbers separated by comma: 1
IndexError Traceback (most recent call last)
IndexError: list index out of range

不过,很显然,这样强调一种类型的写法有很大的局限性。那么,该怎么解决这个问题呢?

其中一种解决方案,是在except block中加入多种异常的类型,比如下面这样的写法:

try:
    s = input('please enter two numbers separated by comma: ')
    num1 = int(s.split(',')[0].strip())
    num2 = int(s.split(',')[1].strip())
    ...
except (ValueError, IndexError) as err:
    print('Error: {}'.format(err))

print('continue')
...

或者第二种写法:

try:
    s = input('please enter two numbers separated by comma: ')
    num1 = int(s.split(',')[0].strip())
    num2 = int(s.split(',')[1].strip())
    ...
except ValueError as err:
    print('Value Error: {}'.format(err))
except IndexError as err:
    print('Index Error: {}'.format(err))

print('continue')
...

这样,每次程序执行时,except block中只要有一个exception类型与实际匹配即可。

不过,很多时候,我们很难保证程序覆盖所有的异常类型,所以,更通常的做法,是在最后一个except block,声明其处理的异常类型是Exception。Exception是其他所有非系统异常的基类,能够匹配任意非系统异常。那么这段代码就可以写成下面这样:

try:
    s = input('please enter two numbers separated by comma: ')
    num1 = int(s.split(',')[0].strip())
    num2 = int(s.split(',')[1].strip())
    ...
except ValueError as err:
    print('Value Error: {}'.format(err))
except IndexError as err:
    print('Index Error: {}'.format(err))
except Exception as err:
    print('Other error: {}'.format(err))

print('continue')
...

或者,你也可以在except后面省略异常类型,这表示与任意异常相匹配(包括系统异常等):

try:
    s = input('please enter two numbers separated by comma: ')
    num1 = int(s.split(',')[0].strip())
    num2 = int(s.split(',')[1].strip())
    ...
except ValueError as err:
    print('Value Error: {}'.format(err))
except IndexError as err:
    print('Index Error: {}'.format(err))
except:
    print('Other error')

print('continue')
...

需要注意,当程序中存在多个except block时,最多只有一个except block会被执行。换句话说,如果多个except声明的异常类型都与实际相匹配,那么只有最前面的except block会被执行,其他则被忽略。

异常处理中,还有一个很常见的用法是finally,经常和try、except放在一起来用。无论发生什么情况,finally block中的语句都会被执行,哪怕前面的try和excep block中使用了return语句。

一个常见的应用场景,便是文件的读取:

import sys
try:
    f = open('file.txt''r')
    .... # some data processing
except OSError as err:
    print('OS error: {}'.format(err))
except:
    print('Unexpected error:', sys.exc_info()[0])
finally:
    f.close()

这段代码中,try block尝试读取file.txt这个文件,并对其中的数据进行一系列的处理,到最后,无论是读取成功还是读取失败,程序都会执行finally中的语句——关闭这个文件流,确保文件的完整性。因此,在finally中,我们通常会放一些 无论如何都要执行 的语句。

值得一提的是,对于文件的读取,我们也常常使用with open,你也许在前面的例子中已经看到过,with open会在最后自动关闭文件,让语句更加简洁。

用户自定义异常

前面的例子里充斥了很多Python内置的异常类型,你可能会问,我可以创建自己的异常类型吗?

答案是肯定是,Python当然允许我们这么做。下面这个例子,我们创建了自定义的异常类型MyInputError,定义并实现了初始化函数和str函数(直接print时调用):

class MyInputError(Exception):
    """Exception raised when there're errors in input"""
    def __init__(self, value): # 自定义异常类型的初始化
        self.value = value
    def __str__(self): # 自定义异常类型的string表达形式
        return ("{} is invalid input".format(repr(self.value)))

try:
    raise MyInputError(1) # 抛出MyInputError这个异常
except MyInputError as err:
    print('error: {}'.format(err))

如果你执行上述代码块并输出,便会得到下面的结果:

error: 1 is invalid input

实际工作中,如果内置的异常类型无法满足我们的需求,或者为了让异常更加详细、可读,想增加一些异常类型的其他功能,我们可以自定义所需异常类型。不过,大多数情况下,Python内置的异常类型就足够好了。

异常的使用场景与注意点

学完了前面的基础知识,接下来我们着重谈一下,异常的使用场景与注意点。

通常来说,在程序中,如果我们不确定某段代码能否成功执行,往往这个地方就需要使用异常处理。除了上述文件读取的例子,我可以再举一个例子来说明。

大型社交网站的后台,需要针对用户发送的请求返回相应记录。用户记录往往储存在key-value结构的数据库中,每次有请求过来后,我们拿到用户的ID,并用ID查询数据库中此人的记录,就能返回相应的结果。

而数据库返回的原始数据,往往是json string的形式,这就需要我们首先对json string进行decode(解码),你可能很容易想到下面的方法:

import json
raw_data = queryDB(uid) # 根据用户的id,返回相应的信息
data = json.loads(raw_data)

这样的代码是不是就足够了呢?

要知道,在json.loads()函数中,输入的字符串如果不符合其规范,那么便无法解码,就会抛出异常,因此加上异常处理十分必要。

try:
    data = json.loads(raw_data)
    ....
except JSONDecodeError as err:
    print('JSONDecodeError: {}'.format(err))

不过,有一点切记,我们不能走向另一个极端——滥用异常处理。

比如,当你想要查找字典中某个键对应的值时,绝不能写成下面这种形式:

d = {'name''jason''age': 20}
try:
    value = d['dob']
    ...
except KeyError as err:
    print('KeyError: {}'.format(err))

诚然,这样的代码并没有bug,但是让人看了摸不着头脑,也显得很冗余。如果你的代码中充斥着这种写法,无疑对阅读、协作来说都是障碍。因此,对于flow-control(流程控制)的代码逻辑,我们一般不用异常处理。

字典这个例子,写成下面这样就很好。

if 'dob' in d:
    value = d['dob']
    ...

函数

那么,到底什么是函数,如何在Python程序中定义函数呢?

说白了,函数就是为了实现某一功能的代码段,只要写好以后,就可以重复利用。我们先来看下面一个简单的例子:

def my_func(message):
    print('Got a message: {}'.format(message))

# 调用函数 my_func()
my_func('Hello World')
# 输出
Got a message: Hello World

其中:

  • def是函数的声明;

  • my_func是函数的名称;

  • 括号里面的message则是函数的参数;

  • 而print那行则是函数的主体部分,可以执行相应的语句;

  • 在函数最后,你可以返回调用结果(return或yield),也可以不返回。

总结一下,大概是下面的这种形式:

def name(param1, param2, ..., paramN):
    statements
    return/yield value # optional

和其他需要编译的语言(比如C语言)不一样的是,def是可执行语句,这意味着函数直到被调用前,都是不存在的。当程序调用函数时,def语句才会创建一个新的函数对象,并赋予其名字。

我们一起来看几个例子,加深你对函数的印象:

def my_sum(a, b):
    return a + b

result = my_sum(3, 5)
print(result)

# 输出
8

这里,我们定义了my_sum()这个函数,它有两个参数a和b,作用是相加;随后,调用my_sum()函数,分别把3和5赋于a和b;最后,返回其相加的值,赋于变量result,并输出得到8。

再来看一个例子:

def find_largest_element(l):
    if not isinstance(l, list):
        print('input is not type of list')
        return
    if len(l) == 0:
        print('empty input')
        return
    largest_element = l[0]
    for item in l:
        if item > largest_element:
            largest_element = item
    print('largest element is: {}'.format(largest_element))

find_largest_element([8, 1,-3, 2, 0])

# 输出
largest element is: 8

这个例子中,我们定义了函数find_largest_element,作用是遍历输入的列表,找出最大的值并打印。因此,当我们调用它,并传递列表 [8, 1, -3, 2, 0] 作为参数时,程序就会输出 largest element is: 8

需要注意,主程序调用函数时,必须保证这个函数此前已经定义过,不然就会报错,比如:

my_func('hello world')
def my_func(message):
    print('Got a message: {}'.format(message))

# 输出
NameError: name 'my_func' is not defined

但是,如果我们在函数内部调用其他函数,函数间哪个声明在前、哪个在后就无所谓,因为def是可执行语句,函数在调用之前都不存在,我们只需保证调用时,所需的函数都已经声明定义:

def my_func(message):
    my_sub_func(message) # 调用my_sub_func()在其声明之前不影响程序执行

def my_sub_func(message):
    print('Got a message: {}'.format(message))

my_func('hello world')

# 输出
Got a message: hello world

另外,Python函数的参数可以设定默认值,比如下面这样的写法:

def func(param = 0):
    ...

这样,在调用函数func()时,如果参数param没有传入,则参数默认为0;而如果传入了参数param,其就会覆盖默认值。

前面说过,Python和其他语言相比的一大特点是,Python是dynamically typed的,可以接受任何数据类型(整型,浮点,字符串等等)。对函数参数来说,这一点同样适用。比如还是刚刚的my_sum函数,我们也可以把列表作为参数来传递,表示将两个列表相连接:

print(my_sum([1, 2], [3, 4]))

# 输出
[1, 2, 3, 4]

同样,也可以把字符串作为参数传递,表示字符串的合并拼接:

print(my_sum('hello ''world'))

# 输出
hello world

当然,如果两个参数的数据类型不同,比如一个是列表、一个是字符串,两者无法相加,那就会报错:

print(my_sum([1, 2], 'hello'))
TypeError: can only concatenate list (not "str") to list

我们可以看到,Python不用考虑输入的数据类型,而是将其交给具体的代码去判断执行,同样的一个函数(比如这边的相加函数my_sum()),可以同时应用在整型、列表、字符串等等的操作中。

在编程语言中,我们把这种行为称为 多态。这也是Python和其他语言,比如Java、C等很大的一个不同点。当然,Python这种方便的特性,在实际使用中也会带来诸多问题。因此,必要时请你在开头加上数据的类型检查。

Python函数的另一大特性,是Python支持函数的嵌套。所谓的函数嵌套,就是指函数里面又有函数,比如:

def f1():
    print('hello')
    def f2():
        print('world')
    f2()
f1()

# 输出
hello
world

这里函数f1()的内部,又定义了函数f2()。在调用函数f1()时,会先打印字符串 'hello',然后f1()内部再调用f2(),打印字符串 'world'。你也许会问,为什么需要函数嵌套?这样做有什么好处呢?

其实,函数的嵌套,主要有下面两个方面的作用。

第一,函数的嵌套能够保证内部函数的隐私。内部函数只能被外部函数所调用和访问,不会暴露在全局作用域,因此,如果你的函数内部有一些隐私数据(比如数据库的用户、密码等),不想暴露在外,那你就可以使用函数的的嵌套,将其封装在内部函数中,只通过外部函数来访问。比如:

def connect_DB():
    def get_DB_configuration():
        ...
        return host, username, password
    conn = connector.connect(get_DB_configuration())
    return conn

这里的函数get_DB_configuration,便是内部函数,它无法在connect_DB()函数以外被单独调用。也就是说,下面这样的外部直接调用是错误的:

get_DB_configuration()

# 输出
NameError: name 'get_DB_configuration' is not defined

我们只能通过调用外部函数connect_DB()来访问它,这样一来,程序的安全性便有了很大的提高。

第二,合理的使用函数嵌套,能够提高程序的运行效率。我们来看下面这个例子:

def factorial(input):
    # validation check
    if not isinstance(input, int):
        raise Exception('input must be an integer.')
    if input < 0:
        raise Exception('input must be greater or equal to 0' )
    ...

    def inner_factorial(input):
        if input <= 1:
            return 1
        return input * inner_factorial(input-1)
    return inner_factorial(input)

print(factorial(5))

这里,我们使用递归的方式计算一个数的阶乘。因为在计算之前,需要检查输入是否合法,所以我写成了函数嵌套的形式,这样一来,输入是否合法就只用检查一次。而如果我们不使用函数嵌套,那么每调用一次递归便会检查一次,这是没有必要的,也会降低程序的运行效率。

实际工作中,如果你遇到相似的情况,输入检查不是很快,还会耗费一定的资源,那么运用函数的嵌套就十分必要了。

函数变量作用域

Python函数中变量的作用域和其他语言类似。如果变量是在函数内部定义的,就称为局部变量,只在函数内部有效。一旦函数执行完毕,局部变量就会被回收,无法访问,比如下面的例子:

def read_text_from_file(file_path):
    with open(file_path) as file:
        ...

我们在函数内部定义了file这个变量,这个变量只在read_text_from_file这个函数里有效,在函数外部则无法访问。

相对应的,全局变量则是定义在整个文件层次上的,比如下面这段代码:

MIN_VALUE = 1
MAX_VALUE = 10
def validation_check(value):
    if value < MIN_VALUE or value > MAX_VALUE:
        raise Exception('validation check fails')

这里的MIN_VALUE和MAX_VALUE就是全局变量,可以在文件内的任何地方被访问,当然在函数内部也是可以的。不过,我们 不能在函数内部随意改变全局变量的值。比如,下面的写法就是错误的:

MIN_VALUE = 1
MAX_VALUE = 10
def validation_check(value):
    ...
    MIN_VALUE += 1
    ...
validation_check(5)

如果运行这段代码,程序便会报错:

UnboundLocalError: local variable 'MIN_VALUE' referenced before assignment

这是因为,Python的解释器会默认函数内部的变量为局部变量,但是又发现局部变量MIN_VALUE并没有声明,因此就无法执行相关操作。所以,如果我们一定要在函数内部改变全局变量的值,就必须加上global这个声明:

MIN_VALUE = 1
MAX_VALUE = 10
def validation_check(value):
    global MIN_VALUE
    ...
    MIN_VALUE += 1
    ...
validation_check(5)

这里的global关键字,并不表示重新创建了一个全局变量MIN_VALUE,而是告诉Python解释器,函数内部的变量MIN_VALUE,就是之前定义的全局变量,并不是新的全局变量,也不是局部变量。这样,程序就可以在函数内部访问全局变量,并修改它的值了。

另外,如果遇到函数内部局部变量和全局变量同名的情况,那么在函数内部,局部变量会覆盖全局变量,比如下面这种:

MIN_VALUE = 1
MAX_VALUE = 10
def validation_check(value):
    MIN_VALUE = 3
    ...

在函数validation_check()内部,我们定义了和全局变量同名的局部变量MIN_VALUE,那么,MIN_VALUE在函数内部的值,就应该是3而不是1了。

类似的,对于嵌套函数来说,内部函数可以访问外部函数定义的变量,但是无法修改,若要修改,必须加上nonlocal这个关键字:

def outer():
    x = "local"
    def inner():
        nonlocal x # nonlocal关键字表示这里的x就是外部函数outer定义的变量x
        x = 'nonlocal'
        print("inner:", x)
    inner()
    print("outer:", x)
outer()
# 输出
inner: nonlocal
outer: nonlocal

如果不加上nonlocal这个关键字,而内部函数的变量又和外部函数变量同名,那么同样的,内部函数变量会覆盖外部函数的变量。

def outer():
    x = "local"
    def inner():
        x = 'nonlocal' # 这里的x是inner这个函数的局部变量
        print("inner:", x)
    inner()
    print("outer:", x)
outer()
# 输出
inner: nonlocal
outer: local

闭包

闭包其实和刚刚讲的嵌套函数类似,不同的是,这里外部函数返回的是一个函数,而不是一个具体的值。返回的函数通常赋于一个变量,这个变量可以在后面被继续执行调用。

举个例子你就更容易理解了。比如,我们想计算一个数的n次幂,用闭包可以写成下面的代码:

def nth_power(exponent):
    def exponent_of(base):
        return base ** exponent
    return exponent_of # 返回值是exponent_of函数

square = nth_power(2) # 计算一个数的平方
cube = nth_power(3) # 计算一个数的立方
square
# 输出
<function __main__.nth_power.<locals>.exponent(base)>

cube
# 输出
<function __main__.nth_power.<locals>.exponent(base)>

print(square(2))  # 计算2的平方
print(cube(2)) # 计算2的立方
# 输出
# 2^2
# 2^3

这里外部函数nth_power()返回值,是函数exponent_of(),而不是一个具体的数值。需要注意的是,在执行完 square = nth_power(2)cube = nth_power(3) 后,外部函数nth_power()的参数exponent,仍然会被内部函数exponent_of()记住。这样,之后我们调用square(2)或者cube(2)时,程序就能顺利地输出结果,而不会报错说参数exponent没有定义了。

看到这里,你也许会思考,为什么要闭包呢?上面的程序,我也可以写成下面的形式啊!

def nth_power_rewrite(base, exponent):
    return base ** exponent

确实可以,不过,要知道,使用闭包的一个原因,是让程序变得更简洁易读。设想一下,比如你需要计算很多个数的平方,那么你觉得写成下面哪一种形式更好呢?

# 不适用闭包
res1 = nth_power_rewrite(base1, 2)
res2 = nth_power_rewrite(base2, 2)
res3 = nth_power_rewrite(base3, 2)
...

# 使用闭包
square = nth_power(2)
res1 = square(base1)
res2 = square(base2)
res3 = square(base3)
...

显然是第二种,是不是?首先直观来看,第二种形式,让你每次调用函数都可以少输入一个参数,表达更为简洁。

其次,和上面讲到的嵌套函数优点类似,函数开头需要做一些额外工作,而你又需要多次调用这个函数时,将那些额外工作的代码放在外部函数,就可以减少多次调用导致的不必要的开销,提高程序的运行效率。

另外还有一点,我们后面会讲到,闭包常常和装饰器(decorator)一起使用。

匿名函数

首先,什么是匿名函数呢?以下是匿名函数的格式:

lambda argument1, argument2,... argumentN : expression

我们可以看到,匿名函数的关键字是lambda,之后是一系列的参数,然后用冒号隔开,最后则是由这些参数组成的表达式。我们通过几个例子看一下它的用法:

square = lambda x: x**2
square(3)

9

这里的匿名函数只输入一个参数x,输出则是输入x的平方。因此当输入是3时,输出便是9。如果把这个匿名函数写成常规函数的形式,则是下面这样:

def square(x):
    return x**2
square(3)

9

可以看到,匿名函数lambda和常规函数一样,返回的都是一个函数对象(function object),它们的用法也极其相似,不过还是有下面几点区别。

第一,lambda是一个表达式(expression),并不是一个语句(statement)

  • 所谓的表达式,就是用一系列“公式”去表达一个东西,比如 x + 2x**2 等等;

  • 而所谓的语句,则一定是完成了某些功能,比如赋值语句 x = 1 完成了赋值,print语句 print(x) 完成了打印,条件语句 if x < 0: 完成了选择功能等等。

因此,lambda可以用在一些常规函数def不能用的地方,比如,lambda可以用在列表内部,而常规函数却不能:

[(lambda x: x*x)(x) for x in range(10)]
# 输出
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

再比如,lambda可以被用作某些函数的参数,而常规函数def也不能:

l = [(1, 20), (3, 0), (9, 10), (2, -1)]
l.sort(key=lambda x: x[1]) # 按列表中元组的第二个元素排序
print(l)
# 输出
[(2, -1), (3, 0), (9, 10), (1, 20)]

常规函数def必须通过其函数名被调用,因此必须首先被定义。但是作为一个表达式的lambda,返回的函数对象就不需要名字了。

第二,lambda的主体是只有一行的简单表达式,并不能扩展成一个多行的代码块。

这其实是出于设计的考虑。Python之所以发明lambda,就是为了让它和常规函数各司其职:lambda专注于简单的任务,而常规函数则负责更复杂的多行逻辑。关于这点,Python之父Guido van Rossum曾发了一篇 文章 解释,你有兴趣的话可以自己阅读。

为什么要使用匿名函数?

理论上来说,Python中有匿名函数的地方,都可以被替换成等价的其他表达形式。一个Python程序是可以不用任何匿名函数的。不过,在一些情况下,使用匿名函数lambda,可以帮助我们大大简化代码的复杂度,提高代码的可读性。

通常,我们用函数的目的无非是这么几点:

  1. 减少代码的重复性;

  2. 模块化代码。

对于第一点,如果你的程序在不同地方包含了相同的代码,那么我们就会把这部分相同的代码写成一个函数,并为它取一个名字,方便在相对应的不同地方调用。

对于第二点,如果你的一块儿代码是为了实现一个功能,但内容非常多,写在一起降低了代码的可读性,那么通常我们也会把这部分代码单独写成一个函数,然后加以调用。

不过,再试想一下这样的情况。你需要一个函数,但它非常简短,只需要一行就能完成;同时它在程序中只被调用一次而已。那么请问,你还需要像常规函数一样,给它一个定义和名字吗?

答案当然是否定的。这种情况下,函数就可以是匿名的,你只需要在适当的地方定义并使用,就能让匿名函数发挥作用了。

举个例子,如果你想对一个列表中的所有元素做平方操作,而这个操作在你的程序中只需要进行一次,用lambda函数可以表示成下面这样:

squared = map(lambda x: x**2, [1, 2, 3, 4, 5])

如果用常规函数,则表示为这几行代码:

def square(x):
    return x**2

squared = map(square, [1, 2, 3, 4, 5])

这里我简单解释一下。函数map(function, iterable)的第一个参数是函数对象,第二个参数是一个可以遍历的集合,它表示对iterable的每一个元素,都运用function这个函数。两者一对比,我们很明显地发现,lambda函数让代码更加简洁明了。

再举一个例子,在Python的Tkinter GUI应用中,我们想实现这样一个简单的功能:创建显示一个按钮,每当用户点击时,就打印出一段文字。如果使用lambda函数可以表示成下面这样:

from tkinter import Button, mainloop
button = Button(
    text='This is a button',
    command=lambda: print('being pressed')) # 点击时调用lambda函数
button.pack()
mainloop()

而如果我们用常规函数def,那么需要写更多的代码:

from tkinter import Button, mainloop

def print_message():
    print('being pressed')

button = Button(
    text='This is a button',
    command=print_message) # 点击时调用lambda函数
button.pack()
mainloop()

显然,运用匿名函数的代码简洁很多,也更加符合Python的编程习惯。

Python函数式编程

最后,我们一起来看一下,Python的函数式编程特性,这与我们今天所讲的匿名函数lambda,有着密切的联系。

所谓函数式编程,是指代码中每一块都是不可变的(immutable),都由纯函数(pure function)的形式组成。这里的纯函数,是指函数本身相互独立、互不影响,对于相同的输入,总会有相同的输出,没有任何副作用。

举个很简单的例子,比如对于一个列表,我想让列表中的元素值都变为原来的两倍,我们可以写成下面的形式:

def multiply_2(l):
    for index in range(0, len(l)):
        l[index] *= 2
    return l

这段代码就不是一个纯函数的形式,因为列表中元素的值被改变了,如果我多次调用multiply_2()这个函数,那么每次得到的结果都不一样。要想让它成为一个纯函数的形式,就得写成下面这种形式,重新创建一个新的列表并返回。

def multiply_2_pure(l):
    new_list = []
    for item in l:
        new_list.append(item * 2)
    return new_list

函数式编程的优点,主要在于其纯函数和不可变的特性使程序更加健壮,易于调试(debug)和测试;缺点主要在于限制多,难写。当然,Python不同于一些语言(比如Scala),它并不是一门函数式编程语言,不过,Python也提供了一些函数式编程的特性,值得我们了解和学习。

Python主要提供了这么几个函数:map()、filter()和reduce(),通常结合匿名函数lambda一起使用。这些都是你需要掌握的东西,接下来我逐一介绍。

首先是map(function, iterable)函数,前面的例子提到过,它表示,对iterable中的每个元素,都运用function这个函数,最后返回一个新的可遍历的集合。比如刚才列表的例子,要对列表中的每个元素乘以2,那么用map就可以表示为下面这样:

l = [1, 2, 3, 4, 5]
new_list = map(lambda x: x * 2, l) # [2, 4, 6, 8, 10]

我们可以以map()函数为例,看一下Python提供的函数式编程接口的性能。还是同样的列表例子,它还可以用for循环和list comprehension(目前没有统一中文叫法,你也可以直译为列表理解等)实现,我们来比较一下它们的速度:

python3 -mtimeit -s'xs=range(1000000)' 'map(lambda x: x*2, xs)'
2000000 loops, best of 5: 171 nsec per loop

python3 -mtimeit -s'xs=range(1000000)' '[x * 2 for x in xs]'
5 loops, best of 5: 62.9 msec per loop

python3 -mtimeit -s'xs=range(1000000)' 'l = []' 'for i in xs: l.append(i * 2)'
5 loops, best of 5: 92.7 msec per loop

你可以看到,map()是最快的。因为map()函数直接由C语言写的,运行时不需要通过Python解释器间接调用,并且内部做了诸多优化,所以运行速度最快。

接下来来看filter(function, iterable)函数,它和map函数类似,function同样表示一个函数对象。filter()函数表示对iterable中的每个元素,都使用function判断,并返回True或者False,最后将返回True的元素组成一个新的可遍历的集合。

举个例子,比如我要返回一个列表中的所有偶数,可以写成下面这样:

l = [1, 2, 3, 4, 5]
new_list = filter(lambda x: x % 2 == 0, l) # [2, 4]

最后我们来看reduce(function, iterable)函数,它通常用来对一个集合做一些累积操作。

function同样是一个函数对象,规定它有两个参数,表示对iterable中的每个元素以及上一次调用后的结果,运用function进行计算,所以最后返回的是一个单独的数值。

举个例子,我想要计算某个列表元素的乘积,就可以用reduce()函数来表示:

l = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x * y, l) # 1*2*3*4*5 = 120

当然,类似的,filter()和reduce()的功能,也可以用for循环或者list comprehension来实现。

通常来说,在我们想对集合中的元素进行一些操作时,如果操作非常简单,比如相加、累积这种,那么我们优先考虑map()、filter()、reduce()这类或者list comprehension的形式。至于这两种方式的选择:

  • 在数据量非常多的情况下,比如机器学习的应用,那我们一般更倾向于函数式编程的表示,因为效率更高;

  • 在数据量不多的情况下,并且你想要程序更加Pythonic的话,那么list comprehension也不失为一个好选择。

不过,如果你要对集合中的元素,做一些比较复杂的操作,那么,考虑到代码的可读性,我们通常会使用for循环,这样更加清晰明了。

模块化

说到最简单的模块化方式,你可以把函数、类、常量拆分到不同的文件,把它们放在同一个文件夹,然后使用 from your_file import function_name, class_name 的方式调用。之后,这些函数和类就可以在文件内直接使用了。

# utils.py

def get_sum(a, b):
    return a + b

# class_utils.py

class Encoder(object):
    def encode(self, s):
        return s[::-1]

class Decoder(object):
    def decode(self, s):
        return ''.join(reversed(list(s)))

# main.py

from utils import get_sum
from class_utils import *

print(get_sum(1, 2))

encoder = Encoder()
decoder = Decoder()

print(encoder.encode('abcde'))
print(decoder.decode('edcba'))

########## 输出 ##########

3
edcba
abcde

我们来看这种方式的代码:get_sum() 函数定义在 utils.py,Encoder 和 Decoder 类则在 class_utils.py,我们在 main 函数直接调用 from import ,就可以将我们需要的东西 import 过来。

非常简单。

但是这就足够了吗?当然不,慢慢地,你会发现,所有文件都堆在一个文件夹下也并不是办法。

于是,我们试着建一些子文件夹:

# utils/utils.py

def get_sum(a, b):
    return a + b

# utils/class_utils.py

class Encoder(object):
    def encode(self, s):
        return s[::-1]

class Decoder(object):
    def decode(self, s):
        return ''.join(reversed(list(s)))

# src/sub_main.py

import sys
sys.path.append("..")

from utils.class_utils import *

encoder = Encoder()
decoder = Decoder()

print(encoder.encode('abcde'))
print(decoder.decode('edcba'))

########## 输出 ##########

edcba
abcde

而这一次,我们的文件结构是下面这样的:

.
├── utils
│   ├── utils.py
│   └── class_utils.py
├── src
│   └── sub_main.py
└── main.py

很容易看出,main.py 调用子目录的模块时,只需要使用 . 代替 / 来表示子目录,utils.utils 表示 utils 子文件夹下的 utils.py 模块就行。

那如果我们想调用上层目录呢?注意, sys.path.append("..") 表示将当前程序所在位置 向上 提了一级,之后就能调用 utils 的模块了。

同时要注意一点,import 同一个模块只会被执行一次,这样就可以防止重复导入模块出现问题。当然,良好的编程习惯应该杜绝代码多次导入的情况。 在Facebook 的编程规范中,除了一些极其特殊的情况,import 必须位于程序的最前端

最后我想再提一下版本区别。你可能在许多教程中看到过这样的要求:我们还需要在模块所在的文件夹新建一个 __init__.py,内容可以为空,也可以用来表述包对外暴露的模块接口。不过,事实上,这是 Python 2 的规范。在 Python 3 规范中, __init__.py 并不是必须的,很多教程里没提过这一点,或者没讲明白,我希望你还是能注意到这个地方。

整体而言,这就是最简单的模块调用方式了。在我初用 Python 时,这种方式已经足够我完成大学期间的项目了,毕竟,很多学校项目的文件数只有个位数,每个文件代码也只有几百行,这种组织方式能帮我顺利完成任务。

但是在我来到 Facebook后,我发现,一个项目组的 workspace 可能有上千个文件,有几十万到几百万行代码。这种调用方式已经完全不够用了,学会新的组织方式迫在眉睫。

接下来,我们就系统学习下,模块化的科学组织方式。

项目模块化

我们先来回顾下相对路径和绝对路径的概念。

在 Linux 系统中,每个文件都有一个绝对路径,以 / 开头,来表示从根目录到叶子节点的路径,例如 /home/ubuntu/Desktop/my_project/test.py,这种表示方法叫作绝对路径。

另外,对于任意两个文件,我们都有一条通路可以从一个文件走到另一个文件,例如 /home/ubuntu/Downloads/example.json。再如,我们从 test.py 访问到 example.json,需要写成 '../../Downloads/example.json',其中 .. 表示上一层目录。这种表示方法,叫作相对路径。

通常,一个 Python 文件在运行的时候,都会有一个运行时位置,最开始时即为这个文件所在的文件夹。当然,这个运行路径以后可以被改变。运行 sys.path.append("..") ,则可以改变当前 Python 解释器的位置。不过,一般而言我并不推荐,固定一个确定路径对大型工程来说是非常必要的。

理清楚这些概念后,我们就很容易搞懂,项目中如何设置模块的路径。

首先,你会发现,相对位置是一种很不好的选择。因为代码可能会迁移,相对位置会使得重构既不雅观,也易出错。因此,在大型工程中尽可能使用绝对位置是第一要义。对于一个独立的项目,所有的模块的追寻方式,最好从项目的根目录开始追溯,这叫做相对的绝对路径。

事实上,在 Facebook 和 Google,整个公司都只有一个代码仓库,全公司的代码都放在这个库里。我刚加入 Facebook 时对此感到很困惑,也很新奇,难免会有些担心:

  • 这样做似乎会增大项目管理的复杂度吧?
  • 是不是也会有不同组代码隐私泄露的风险呢?

后来,随着工作的深入,我才发现了这种代码仓库独有的几个优点。

第一个优点,简化依赖管理。整个公司的代码模块,都可以被你写的任何程序所调用,而你写的库和模块也会被其他人调用。调用的方式,都是从代码的根目录开始索引,也就是前面提到过的相对的绝对路径。这样极大地提高了代码的分享共用能力,你不需要重复造轮子,只需要在写之前,去搜一下有没有已经实现好的包或者框架就可以了。

第二个优点,版本统一。不存在使用了一个新模块,却导致一系列函数崩溃的情况;并且所有的升级都需要通过单元测试才可以继续。

第三个优点,代码追溯。你可以很容易追溯,一个 API 是从哪里被调用的,它的历史版本是怎样迭代开发,产生变化的。

如果你有兴趣,可以参考这篇论文: https://cacm.acm.org/magazines/2016/7/204032-why-google-stores-billions-of-lines-of-code-in-a-single-repository/fulltext

在做项目的时候,虽然你不可能把全世界的代码都放到一个文件夹下,但是类似模块化的思想还是要有的——那就是以项目的根目录作为最基本的目录,所有的模块调用,都要通过根目录一层层向下索引的方式来 import。

明白了这一点后,这次我们使用 PyCharm 来创建一个项目。这个项目结构如下所示:

.
├── proto
│   ├── mat.py
├── utils
│   └── mat_mul.py
└── src
    └── main.py

# proto/mat.py

class Matrix(object):
    def __init__(self, data):
        self.data = data
        self.n = len(data)
        self.m = len(data[0])

# utils/mat_mul.py

from proto.mat import Matrix

def mat_mul(matrix_1: Matrix, matrix_2: Matrix):
    assert matrix_1.m == matrix_2.n
    n, m, s = matrix_1.n, matrix_1.m, matrix_2.m
    result = [[0 for _ in range(n)] for _ in range(s)]
    for i in range(n):
        for j in range(s):
            for k in range(m):
                result[i][k] += matrix_1.data[i][j] * matrix_2.data[j][k]

    return Matrix(result)

# src/main.py

from proto.mat import Matrix
from utils.mat_mul import mat_mul

a = Matrix([[1, 2], [3, 4]])
b = Matrix([[5, 6], [7, 8]])

print(mat_mul(a, b).data)

########## 输出 ##########

[[19, 22], [43, 50]]

这个例子和前面的例子长得很像,但请注意 utils/mat_mul.py,你会发现,它 import Matrix 的方式是 from proto.mat。这种做法,直接从项目根目录中导入,并依次向下导入模块 mat.py 中的 Matrix,而不是使用 .. 导入上一级文件夹。

是不是很简单呢?对于接下来的所有项目,你都能直接使用 Pycharm 来构建。把不同模块放在不同子文件夹里,跨模块调用则是从顶层直接索引,一步到位,非常方便。

我猜,这时你的好奇心来了。你尝试使用命令行进入 src 文件夹,直接输入 Python main.py,报错,找不到 proto。你不甘心,退回到上一级目录,输入 Python src/main.py,继续报错,找不到 proto。

Pycharm 用了什么黑魔法呢?

实际上,Python 解释器在遇到 import 的时候,它会在一个特定的列表中寻找模块。这个特定的列表,可以用下面的方式拿到:

import sys

print(sys.path)

########## 输出 ##########

['''/usr/lib/python36.zip''/usr/lib/python3.6''/usr/lib/python3.6/lib-dynload''/usr/local/lib/python3.6/dist-packages''/usr/lib/python3/dist-packages']

请注意,它的第一项为空。其实,Pycharm 做的一件事,就是将第一项设置为项目根目录的绝对地址。这样,每次你无论怎么运行 main.py,import 函数在执行的时候,都会去项目根目录中找相应的包。

你说,你想修改下,使得普通的 Python 运行环境也能做到?这里有两种方法可以做到:

import sys

sys.path[0] = '/home/ubuntu/workspace/your_projects'

第一种方法,“大力出奇迹”,我们可以强行修改这个位置,这样,你的 import 接下来肯定就畅通无阻了。但这显然不是最佳解决方案,把绝对路径写到代码里,是我非常不推荐的方式(你可以写到配置文件中,但找配置文件也需要路径寻找,于是就会进入无解的死循环)。

第二种方法,是修改 PYTHONHOME。这里我稍微提一下 Python 的 Virtual Environment(虚拟运行环境)。Python 可以通过 Virtualenv 工具,非常方便地创建一个全新的 Python 运行环境。

事实上,我们提倡,对于每一个项目来说,最好要有一个独立的运行环境来保持包和模块的纯净性。更深的内容超出了今天的范围,你可以自己查资料了解。

回到第二种修改方法上。在一个 Virtual Environment 里,你能找到一个文件叫 activate,在这个文件的末尾,填上下面的内容:

export PYTHONPATH="/home/ubuntu/workspace/your_projects"

这样,每次你通过 activate 激活这个运行时环境的时候,它就会自动将项目的根目录添加到搜索路径中去。

神奇的 if __name__ == '__main__'

最后一部分,我们再来讲讲 if __name__ == '__main__' ,这个我们经常看到的写法。

Python 是脚本语言,和 C++、Java 最大的不同在于,不需要显式提供 main() 函数入口。如果你有 C++、Java 等语言经验,应该对 main() {} 这样的结构很熟悉吧?

不过,既然 Python 可以直接写代码, if __name__ == '__main__' 这样的写法,除了能让 Python 代码更好看(更像 C++ )外,还有什么好处吗?

项目结构如下:

.
├── utils.py
├── utils_with_main.py
├── main.py
└── main_2.py

# utils.py

def get_sum(a, b):
    return a + b

print('testing')
print('{} + {} = {}'.format(1, 2, get_sum(1, 2)))

# utils_with_main.py

def get_sum(a, b):
    return a + b

if __name__ == '__main__':
    print('testing')
    print('{} + {} = {}'.format(1, 2, get_sum(1, 2)))

# main.py

from utils import get_sum

print('get_sum: ', get_sum(1, 2))

########## 输出 ##########

testing
1 + 2 = 3
get_sum: 3

# main_2.py

from utils_with_main import get_sum

print('get_sum: ', get_sum(1, 2))

########## 输出 ##########

get_sum_2: 3

看到这个项目结构,你就很清晰了吧。

import 在导入文件的时候,会自动把所有暴露在外面的代码全都执行一遍。因此,如果你要把一个东西封装成模块,又想让它可以执行的话,你必须将要执行的代码放在 if __name__ == '__main__' 下面。

为什么呢?其实, __name__ 作为 Python 的魔术内置参数,本质上是模块对象的一个属性。我们使用 import 语句时, __name__ 就会被赋值为该模块的名字,自然就不等于 __main__ 了。更深的原理我就不做过多介绍了,你只需要明白这个知识点即可。

总结

Python的基础篇,我们先是讲了关于列表和元组,列表和元组都是有序的,可以存储任意数据类型的集合,区别主要在于下面这两点。

  • 列表是动态的,长度可变,可以随意的增加、删减或改变元素。列表的存储空间略大于元组,性能略逊于元组。

  • 元组是静态的,长度大小固定,不可以对元素进行增加、删减或者改变操作。元组相对于列表更加轻量级,性能稍优。

紧接着我们一起学习了字典和集合的基本操作,并对它们的高性能和内部存储结构进行了讲解。

字典在Python3.7+是有序的数据结构,而集合是无序的,其内部的哈希表存储结构,保证了其查找、插入、删除操作的高效性。所以,字典和集合通常运用在对元素的高效查找、去重等场景。

然后我们学习了Python字符串的一些基本知识和常用操作,并且结合具体的例子与场景加以说明,特别需要注意下面几点。

  • Python中字符串使用单引号、双引号或三引号表示,三者意义相同,并没有什么区别。其中,三引号的字符串通常用在多行字符串的场景。

  • Python中字符串是不可变的(前面所讲的新版本Python中拼接操作’+='是个例外)。因此,随意改变字符串中字符的值,是不被允许的。

  • Python新版本(2.5+)中,字符串的拼接变得比以前高效了许多,你可以放心使用。

  • Python中字符串的格式化(string.format)常常用在输出、日志的记录等场景。

我们还一起学习了条件与循环的基本概念、进阶用法以及相应的应用。这里,我重点强调几个易错的地方。

  • 在条件语句中,if可以单独使用,但是elif和else必须和if同时搭配使用;而If条件语句的判断,除了boolean类型外,其他的最好显示出来。

  • 在for循环中,如果需要同时访问索引和元素,你可以使用enumerate()函数来简化代码。

  • 写条件与循环时,合理利用continue或者break来避免复杂的嵌套,是十分重要的。

  • 要注意条件与循环的复用,简单功能往往可以用一行直接完成,极大地提高代码质量与效率。

然后介绍了 Python 的普通 I/O和文件 I/O,同时了解了 JSON 序列化的基本知识,并通过具体的例子进一步掌握。再次强调一下需要注意的几点:

  • I/O 操作需谨慎,一定要进行充分的错误处理,并细心编码,防止出现编码漏洞;

  • 编码时,对内存占用和磁盘占用要有充分的估计,这样在出错时可以更容易找到原因;

  • JSON序列化是很方便的工具,要结合实战多多练习;

  • 代码尽量简洁、清晰

关于Python程序的异常处理,你需要注意以下几点:

  • 异常,通常是指程序运行的过程中遇到了错误,终止并退出。我们通常使用try except语句去处理异常,这样程序就不会被终止,仍能继续执行。

  • 处理异常时,如果有必须执行的语句,比如文件打开后必须关闭等等,则可以放在finally block中。

  • 异常处理,通常用在你不确定某段代码能否成功执行,也无法轻易判断的情况下,比如数据库的连接、读取等等。正常的flow-control逻辑,不要使用异常处理,直接用条件语句解决就可以了。

关于Python的函数我们了解了Python函数的概念及其应用,有这么几点你需要注意:

  1. Python中函数的参数可以接受任意的数据类型,使用起来需要注意,必要时请在函数开头加入数据类型的检查;

  2. 和其他语言不同,Python中函数的参数可以设定默认值;

  3. 嵌套函数的使用,能保证数据的隐私性,提高程序运行效率;

  4. 合理地使用闭包,则可以简化程序的复杂度,提高可读性。

  5. 匿名函数lambda,它的主要用途是减少代码的复杂度。需要注意的是lambda是一个表达式,并不是一个语句;它只能写成一行的表达形式,语法上并不支持多行。

  6. 匿名函数通常的使用场景是:程序中需要使用一个函数完成一个简单的功能,并且该函数只调用一次。

其次,我们也入门了Python的函数式编程,主要了解了常见的map(),fiilter()和reduce()三个函数,并比较了它们与其他形式(for循环,comprehension)的性能,显然,它们的性能效率是最优的。

最后如何使用 Python 来构建模块化和大型工程。这里需要强调几点:

  1. 通过绝对路径和相对路径,我们可以 import 模块;
  2. 在大型工程中模块化非常重要,模块的索引要通过绝对路径来做,而绝对路径从程序的根目录开始;
  3. 使用用 if __name__ == '__main__' 来避开 import 时执行。

分类:

后端

标签:

后端

作者介绍

架构狂人
V1

公众号【顶尖架构师栈】