欢迎关注 ，专注Python、数据分析、数据挖掘、好玩工具！
一、前言
经常有人会问：Python 有哪些让你相见恨晚的技巧？我今天准备把这个问题认真回答一下。我会先讨论什么是优美的代码；然后，我会给出一些我压箱底的好东西；最后，我会讨论怎么写出优美的代码。
二、什么是优美（优雅）的代码
什么是优美或优雅的代码实现呢？在Python里面，我们一般称之为Pythonic。Pythonic并没有一个确切的定义，一直以来都是只能意会，不能言传的东西。为了帮助新同学理解，我对Pythonic给出了明确的定义：所谓Pythonic，就是用Python的方式写出简洁优美的代码。
有了Pythonic以后，不同的工程师之间，也依然无法对优美的代码达成一致的意见。因为，美本身是一个主观感受，每个人对美的感受是不一样的。比如，有些人觉得汤唯更美，有些人觉得范冰冰最漂亮，还有些人居然喜欢AngelaBaby。而我，依然最喜欢刘涛。我在这篇文章中，会给出很多具体的例子，来说明怎样写代码是’美’的，由于美是一种主观感受，所以，这里的回答可能会引起大家的争议。
另外，在这篇文章中，我们只讨论优美的Python代码实现，并不讨论Python中存在的坑。我估计Python里面有很多坑大家都没有注意到，比如：
>>> a = 4.2
>>> b = 2.1
>>> print a+b == 6.3
False
三、优美的代码实现
在这一部分，我们会依次讨论一些美的代码。由于内容较多，所以，我进行了简单地分类，包括：
-
内置函数
-
Python中的一些小细节
-
充分使用数据结构的便利性
-
合理使用Python的高级并发工具
-
巧妙使用装饰器简化代码
-
Python中的设计模式
3.1 善用内置函数
enumerate类
enumerate是一个类，但是用起来却跟函数一样方便，为了表述方便，我们后面统称为函数。不使用enumerate可能是Python新手最容易被吐槽的地方了。enumerate其实非常简单，接收一个可迭代对象，返回index和可迭代对象中的元素的组合。
对于Python新手，推荐使用ipython（还有bpython和ptpython，感兴趣的同学也可以了解一下)交互式地测试各个函数的效果，并且，我们可以在函数后面输入一个问号，然后回车，就能够获得这个函数的帮助文档了。如下所示：
In [1]: enumerate?
Type: type
String Form:<type 'enumerate'>
Namespace: Python builtin
Docstring:
enumerate(iterable[, start]) -> iterator for index, value of iterable
Return an enumerate object. iterable must be another object that supports
iteration. The enumerate object yields pairs containing a count (from
start, which defaults to zero) and a value yielded by the iterable argument.
enumerate is useful for obtaining an indexed list:
(0, seq[0]), (1, seq[1]), (2, seq[2]), ...
关于enumerate的效果，我们一起来看一下，你就知道为什么不使用enumerate会被吐槽了。这是不使用enumerate的时候，打印列表中的元素和元素在列表中的位置代码：
from __future__ import print_function
L = [ i*i for i in range(5) ]
index = 0
for data in L:
index += 1
print(index, ':', data)
这是使用enumerate的Python代码:
from __future__ import print_function
L = [ i*i for i in range(5) ]
for index, data in enumerate(L):
print(index + 1, ':', data)
这是正确使用enumerate的姿势：
from __future__ import print_function
L = [ i*i for i in range(5) ]
for index, data in enumerate(L, 1):
print(index, ':', data)
去除import语句和列表的定义，实现同样的功能，不使用enumerate需要4行代码，使用enumerate只需要2行代码。如果想把代码写得简洁优美，那么，大家要时刻记住：在保证代码可读性的前提下，代码越少越好。显然，使用enumerate效果就好很多。
reversed
对Python熟悉的同学知道，Python中的列表支持切片操作，可以像L[::-1]这样去reverse列表。如下所示：
[1, 2, 3, 4]
>>> for item in L[::-1]:
... print(item)
...
4
3
2
1
与此同时，我们也可以使用内置的reversed函数，如下所示：
>>> for item in reversed(L):
... print(item)
...
4
3
2
1
我的观点是，L[::-1]不如使用reversed好，因为，L[::-1]是一个切片操作。我们看到这个代码的第一反应是序列切片，然后才是切片的效果是reverse列表。对于reversed函数，即使是刚接触Python的同学，也能够一眼看出来这个函数是要做什么事情。也就是说，实现同样的功能，L[::-1]比reversed多绕了一个弯。我们这个问题是如何写出优美的代码，而我认为，优美的代码就应该简洁、直接、少绕弯。
读者如果对我这里的解释表示怀疑的话，我表示理解。但是，我还是想劝你认可我的说法。因为我认为，不管我们使用代码还是文字，都是在表达某些东西。而我的表达能力，也是读研究生以后写论文锻炼出来的。就我目前比大多数人强的表达能力来说，我以我母校的荣誉保证，reversed确实比L[::-1]好。
any
在内置函数中，sort、sum、min和max是大家用的比较多的，也比较熟悉的。像any和all这种函数，是大家都知道，并且觉得很简单，但是使用的时候就想不起来的。我们来看一个具体的例子。
我们现在的需求是判断MySQL中的一张表是否存在主键，有主键的情况，如下所示：
mysql> show index from t;
+-------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| Table | Non_unique | Key_name | Seq_in_index | Column_name | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment | Index_comment |
+-------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| t | 0 | PRIMARY | 1 | id | A | 0 | NULL | NULL | | BTREE | | |
+-------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
1 row in set (0.00 sec)
我们再来看一个没有主键的例子，如下所示：
mysql> show index from t;
+-------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| Table | Non_unique | Key_name | Seq_in_index | Column_name | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment | Index_comment |
+-------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| t | 0 | id | 1 | id | A | 0 | NULL | NULL | | BTREE | | |
| t | 1 | idx_age | 1 | age | A | 0 | NULL | NULL | YES | BTREE | | |
+-------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
2 rows in set (0.00 sec)
在这个没有主键的例子中，虽然没有显示定义主键，但是，它有一个非空的唯一索引。在InnoDB中，如果存在非空的唯一约束，那么，这一列将会被当作主键。综合前面两种情况的输出，我们知道，我们要判断一张表是否存在主键，我们不能通过是否存在一个key_name名为PRIMARY的索引来判断，而应该通过Non_unique为0和Null列不为YES来判断。说完了需求，我们来看一下具体的实现。使用pymysql连接数据库，数据库中的每一行，将会以元组的形式返回，如下所示：
(('t', 0, 'PRIMARY', 1, 'id', 'A', 0, None, None, '', 'BTREE', '', ''),)
也就是说，我们现在要遍历一个二维的元组，然后判断是否存在Non_unique为0，Null列不为YES的记录。详细了解了具体实现以后，我们写下了下面的代码：
def has_primary_key():
for row in rows:
if row[1] == 0 and row[9] != 'YES':
return True
return False
非常的简单，但是，如果我们使用any函数的话，代码将会更短。如下所示：
def has_primary_key():
return any(row[1] == 0 and row[9] != 'YES' for row in rows):
从这一节大家可以看到，即使内置函数这么简单的知识，我们也要充分掌握，灵活使用，才能够写出优美的代码。
3.2 Python中的小细节
这一节我们来看3个很小的知识点。
raise SystemExit
假设你现在要实现一个需求，在程序检测到某种错误的时候，打印错误信息，并退出程序。在Python中，我们可以是SystemExit，如下所示：
import sys
sys.stderr.write('It failed!\n')
raise SystemExit(1)
但是，你其实可以直接这么用的:
raise SystemExit('It failed!')
后面的这个操作会直接将信息打印到标准错误输出，然后使用退出码为1来退出程序，以表示程序没有正常退出。
文件的x模式
大家应该知道，如果我们以w模式打开一个文件进行写入的话，文件的内容将会被我们覆盖掉。假设你现在有这样一个需求：写一个文件，如果该文件已经存在，则不写。实现方式也很简单，我们先判断一下文件是否存在，如果已经存在，则打印提示信息并跳过，否则，我们就以w模式打开文件，然后写入内容。如下所示：
>>> import os
>>> if not os.path.exists('somefile'):
... with open('somefile', 'wt') as f:
... f.write('Hello\n')
... else:
... print('File already exists!')
...
File already exists!
如果我们使用x模式的话，代码能够好看很多，如下所示：
>>> with open('somefile', 'xt') as f:
... f.write('Hello\n')
ConfigParser
上面两个例子知道的人可能比较多，这个例子知道的人可能就不多了。在大部分服务中，会将如数据库连接参数这样的配置，写到配置文件中，然后使用ConfigParser来管理。连接数据库的时候，我们可以读取配置参数，然后生成连接字符串。其实，ConfigParser本身就提供了生成连接字符串的功能，如下所示：
$cat db.conf
[DEFAULT]
conn_str = %(dbn)s://(%user)s:%(pw)s@%(host)s:%(port)s/%(db)s
dbn = mysql
user = root
pw = root
host = localhost
port = 3306
db = test
这里给出了几个Python中的小细节，可能很多人会觉得没啥用，又或者大家其实已经知道了。但是，我还是把这一节放上来了，只要对一个人有用，那么，这就是有意义的。
3.3 合理使用数据结构
这一节中，我们会讨论Python中的部分数据结构的用法，可能是对大家最有用的章节。
字典的get可以传递默认值
很多人是这么给参数赋默认值的：
port = kwargs.get('port')
if port is None:
port = 3306
其实，我们完全不用这么麻烦，因为，字典的get方法支持提供默认参数，在字典没有值的情况下，将会返回用户提供的默认参数，所以，优美的代码应该是这样的：
port = kwargs.get('port', 3306)
我们再来看一个类似的例子，获取元素且删除：
L = [1, 2, 3, 4]
last = L[-1]
L.pop()
这里，我们又多此一举了。因此，在调用L.pop()函数的时候，本身就会返回给我们需要pop的数据。也就是说，我们可以这样：
defaultdict & Counter
我们来看两个不是Python内置的数据类型，而是Python标准库里面的例子。
假设我们的字典中的value是一个list。大家知道，list也是元素的集合。所以，我们会见到很多下面这样的代码，先判断key是否已经存在，如果不存在，则新建一个list并赋值给key，如果已经存在，则调用list的append方法，将值添加进去。
d = {}
for key, value in pairs:
if key not in d:
d[key] = []
d[key].append(value)
如果我们知道defaultdict，那就不用这么麻烦了，如下所示：
d = defaultdict(list)
for key, value in pairs:
d[key].append(value)
我们接着上面的defaultdit的例子来讨论。现在有一个需求，需要统计一个文件中，每个单词出现的次数。很多新同学拿到这个题目，首先想到的是使用字典，所以，写出来下面这样的代码：
d = {}
with open('/etc/passwd') as f:
for line in f:
for word in line.strip().split(':'):
if word not in d:
d[word] = 1
else:
d[word] += 1
如果我们使用前面介绍的defaultdict，代码能够减少3行，会被认为更加Pythonic。如下所示：
d = defaultdict(int)
with open('/etc/passwd') as f:
for line in f:
for word in line.strip().split(':'):
d[word] += 1
对于这个问题，其实还有一个更好的解决办法，使用collections中的Counter。如下：
word_counts = Counter()
with open('/etc/passwd') as f:
for line in f:
word_counts.update(line.strip().split(':'))
可以看到，使用Counter以后，我们的代码更加短小了。我们先把代码重8行重构到5行，然后又重构到4行。记住我前面给出的实践方法：要想把代码写得优美，在保证可读性的前提下，代码越短越好。对于这个问题，使用Counter还有其他的一些理由，那就是其他相关的需求。比如，现在还有第二个需求，打印出现次数最多的三个单词。如果我们使用字典，那么，我们需要这样：
result = sorted(zip(d.values(), d.keys()), reverse=True)[:3]
for val, key in result:
print(key, ':', val)
使用Counter就简单了，因为Counter直接就为我们提供了相应的函数，如下所示：
for key, val in (word_counts.most_common(3)):
print(key, ':', val)
是不是代码更短，看起来更加清晰呢。而且，统计每个单词出现的次数和出现次数最多的单词，这两个需求相关性实在是太强了，几乎会同时出现。所以，我们使用了Counter模块和该模块的most_common方法。如果Counter没有提供这个方法，那才是要被吐槽的！
这个例子就充分说明了，善用标准库的重要性。我们再来看一个标准库的例子。
nametuple
我们要写一个监控系统，该系统要监控主机的方方面面。当然，也包括磁盘相关的监控。我们可以从/proc/diskstats中获取磁盘的详细信息。/proc/diskstats 的内容像下面这样
"""
https://www.kernel.org/doc/Documentation/ABI/testing/procfs-diskstats
What: /proc/diskstats
The /proc/diskstats file displays the I/O statistics
of block devices. Each line contains the following 14
fields:
1 - major number
2 - minor mumber
3 - device name
4 - reads completed successfully
5 - reads merged
6 - sectors read
7 - time spent reading (ms)
8 - writes completed
9 - writes merged
10 - sectors written
11 - time spent writing (ms)
12 - I/Os currently in progress
13 - time spent doing I/Os (ms)
14 - weighted time spent doing I/Os (ms)
"""
$ cat /proc/diskstats
254 0 vda 24471 251 818318 33200 37026 64382 2289256 394516 0 24868 427704
254 1 vda1 24143 229 815530 33156 36072 64382 2289256 394428 0 24748 427572
254 32 vdc 614 0 22180 408 51203 2822 1857922 1051716 0 40792 1052064
/proc/diskstats文件有很多列，如果我们使用下标访问的话，肯定需要借助我们的手指头。并且，也不一定能数清楚。就算你算术特别厉害，能够轻易地数清楚，如果下一个人要来修改你写的代码，对他来说，将会是一个噩梦。
作为一个有追求的程序员，我们当然要寻找更好的办法。对于这个问题，我们可以使用Python中的命名元组，也就是collections中的namedtuple。我们定义命名元组：
DiskDevice = collections.namedtuple('DiskDevice', 'major_number minor_number device_name read_count read_merged_count'
' read_sections time_spent_reading write_count write_merged_count '
'write_sections time_spent_write io_requests time_spent_doing_io'
' weighted_time_spent_doing_io')
有了命名元组以后，如果我们要返回某个磁盘的请求数据，就返回一个命名元组。调用者通过该命名元组，就能够通过属性的方式，而不是下标的方式访问各个字段。获取磁盘监控的代码如下：
def get_disk_info(disk_name):
with open("/proc/diskstats") as f:
for line in f:
if line.split()[2] == disk_name:
#返回给调用者的是一个命名元祖(namedtuple)
return DiskDevice(*(line.split()))
3.4 使用高级并发工具
数据结构先讲到这边，我们来看一个并发的例子。即生产者和消费者模型。分别创建生产者和消费者，生产者向队列中放东西，消费者从队列中取东西。创建一个锁来保证线程间操作的互斥性，当队列满的时候，生产者进入等待状态，当队列空的时候，消费者进入等待状态。下面是一个简单的实现Producer-consumer problem in Python：
from threading import Thread, Condition
import time
import random
queue = []
MAX_NUM = 10
condition = Condition()
class ProducerThread(Thread):
def run(self):
nums = range(5)
global queue
while True:
condition.acquire()
if len(queue) == MAX_NUM:
print "Queue full, producer is waiting"
condition.wait()
print "Space in queue, Consumer notified the producer"
num = random.choice(nums)
queue.append(num)
print "Produced", num
condition.notify()
condition.release()
time.sleep(random.random())
class ConsumerThread(Thread):
def run(self):
global queue
while True:
condition.acquire()
if not queue:
print "Nothing in queue, consumer is waiting"
condition.wait()
print "Producer added something to queue and notified the consumer"
num = queue.pop(0)
print "Consumed", num
condition.notify()
condition.release()
time.sleep(random.random())
ProducerThread().start()
ConsumerThread().start()
对于这一类同步问题，其实，我们应该直接使用Queue。Queue提供了线程安全的队列，特别适合用来解决生产者和消费者问题。这里我再强调一下，Queue本身是线程安全的，而且支持阻塞读、阻塞写。如下所示：
from threading import Thread
import time
import random
from Queue import Queue
queue = Queue(10)
class ProducerThread(Thread):
def run(self):
nums = range(5)
global queue
while True:
num = random.choice(nums)
queue.put(num)
print "Produced", num
time.sleep(random.random())
class ConsumerThread(Thread):
def run(self):
global queue
while True:
num = queue.get()
queue.task_done()
print "Consumed", num
time.sleep(random.random())
ProducerThread().start()
ConsumerThread().start()
可以看到，使用Queue以后，代码量少了很多，可维护性也强了不少。当然了，我这里只是举了一个特别简单的例子，只是想说明，我们应该使用高级的并发工具。
我们再来看一个并发的例子。很多时候，我们要用并发编程，并不用自己手动启动一个线程或进程，完全可以使用Python提供的并发工具，如下所示：
内置的map是单线程运行的，如果涉及到网络请求或者大量的cpu计算，则速度相对会慢很多,因此, 出现了并发的map，如下所示：
import requests
from multiprocessing import Pool
def get_website_data(url):
r = requests.get(url)
return r.url
def main():
urls = ['http://www.google.com',
'http://www.baidu.com',
'http://www.163.com']
pool = Pool(2)
print pool.map(get_website_data, urls)
main()
为了与线程兼容，该模块还提供了multiprocessing.dummy，用以提供线程池的实现，如下所示：
from multiprocessing.dummy import Pool
使用Pool，我们可以快速的在线程池和进程池之间来回切换，最重要的是，使用高级的并发工具不那么容易出错。
3.5 使用装饰器
装饰器可能是Python面试中被问的最多的知识了。之所以如此频繁的出现，是因为，装饰器确实是个好东西。举个例子，我们有两个模块，A模块要发消息给B模块，B模块检查A模块发送过来的参数，没有问题就进行处理，对于检查参数这个操作，如果我们使用装饰器的话，代码将会是下面这样：
import inspect
import functools
def check_args(parameters):
"""check parameters of action"""
def decorated(f):
"""decorator"""
@functools.wraps
def wrapper(*args, **kwargs):
"""wrapper"""
func_args = inspect.getcallargs(f, *args, **kwargs)
msg = func_args.get('msg')
for item in parameters:
if msg.body_dict.get(item) is None:
return False, "check failed, %s is not found" % item
return f(*args, **kwargs)
return wrapper
return decorated
使用的时候：
class AsyncMsgHandler(MsgHandler):
@check.check_args(['ContainerIdentifier', 'MonitorSecretKey', "InstanceID", "UUID"])
def init_container(self, msg):
pass
这样很多好处，例如，我们不用为不同的消息，编写不同的参数检查函数。我们将参数检查和业务逻辑完全分离，使得代码更加简洁明了。当然，装饰器还有各种用处，我就不多说了。
3.6 Python中的设计模式
设计模式本来是与编程语言不相关的，属于程序架构的范畴。但是，有些设计模式，在Python中，完全可以使用Python的一些特性，实现得更加简洁优美。
单例模式
模式是最简单也比较常用的一种模式，所谓单例模式，就是要保证系统中一个类只有一个实例。我们来看一个典型的单例实现：
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
上面这段java代码大家可以轻易地转换成Python的实现，然而，并不Pythonic。给大家一种思路，提供了一个Borg类，只要继承该类，就会成为单例。
class Borg:
_shared_state = {}
def __init__(self):
self.__dict__ = self.__shared_state
这个实现的思路是"实例的唯一性并不是重要的，我们应该关注的是实例的状态，只要所有的实例共享状态，行为一致，那就达到了单例的目的"。通过Borg模式，可以创建任意数量的实例，但因为它们共享状态，从而保证了行为一致。
对Python的模块熟悉的人会知道，在Python中，模块只初始化一次，所有变量归属于某个模块，import机制是线程安全的。所以，模块本身是天然的单例实现。因此，我们可以借助模块来实现单例模式。
下面这个例子创建了一个函数，令其返回含有货币汇率的字典，这个函数可以被多次调用，但是，大部分情况下，汇率数据只获取一次就够了，无须每次调用时都获取一遍。
def get():
if not get.rates:
_URL = 'http://www.bankofcanada.ca/stats/assets/csv/fx-seven-day.csv'
with urllib.request.urlopen(_URL) as file:
for line in file:
# get.rates[key] = float(data)
pass
return get.rates
get.rates = {}
在这段代码中，我们创建了名为rates的字典，用于保存私有数据，并将该字典设置成Rates.get()函数的属性。第一次执行公开的get()函数时，会下载全新的汇率数据；其他时候，只需要把最近下载的那份数据返回就行了。尽管没有引入类，但我们依然把汇率数据做成了"单例数据值"。大家可以看到，在Python中，单例可以直接使用模块来实现，非常的简单。
工厂模式
我们再来看另外一个非常常用的设计模式，工厂模式。下面这段代码是C++编程思想 (豆瓣)中的工厂模式：
class Shape
class Circle: public Shape
class Square: public Shape
Shape* Shape::factory(const string &type)
{
if (type == "Circle")
{return new Circle;}
if (type == "Square")
{return new Square;}
}
说实话，实现得非常好，可读性很强。我们再看一下，同样的需求，在Python中如何实现：
class Shape:pass
class Circle(Shape):pass
class Square(Shape):pass
for name in ["Circle", "Square"]:
cls = globals()[name]
obj = cls()
要理解Python中的工厂模式，关键是要知道，Python中的类也是可调用的对象。而且，我们import以后，存在于当前的命名空间中，所以，我们可以先通过名字获取到"类"，再用类构造出对象。比较这里的C++实现和Python实现可以发现，当我们需要新增一个图形的时候，C++的实现需要去修改Shape::factory函数，Python就不需要这么麻烦，也就是说，Python版本的工厂模式比C++版本的工厂模式少了一个需要维护的函数。从这个角度来说，Python程序员是幸福的。
四、如何写出优美（优雅）的代码
关于这个问题，我想说的还有很多，然而，我编辑了好几天也没有编辑完。总是有个结束的时候，那就到此为止吧。
关于如何能够写出Pythonic的代码，我的观点是：不管用什么语言，你都应该努力写出简洁优美的代码。如果不能，那我推荐你看看《重构》和《代码整洁之道》。虽然这两本书使用的是java语言，但是，并不影响作者要传递的思想。
此外，我也有一些经验传授给大家，希望能够帮助新同学快速地写出还不错的代码。
像写报纸一样写代码
准确无歧义
完整无废话
注意排版以引导读者
注意标点符号以帮助读者
保证可读性的前提下，代码尽可能短小
其中，“保证代码可读性的前提下，代码尽可能短小”，这个我已经反复强调，相信大家已经有点感觉了。我们来看一个"注意标点符号以帮助读者"，在Python里面，空行是会被忽略的，也就说，有没有空行，有多少空行，对Python来说都是一样的，但是，对程序员来说可就不一样了，我们来看一个例子。随机生成1000个0~999之间的整数，然后求他们的和。
这里是没有空行的例子：
import random
def sum_num(num, min_num, max_num):
i = 0
data = []
for i in range(num):
data.append(random.randint(min_num, max_num))
total = 0
for item in data:
total += item
return total
if __name__ == '__main__':
print sum_num(1000, 0, 1000)
这里是有空行的例子：
import random
def sum_num(num, min_num, max_num):
i = 0
data = []
for i in range(num):
data.append(random.randint(min_num, max_num))
total = 0
for item in data:
total += item
return total
if __name__ == '__main__':
print sum_num(1000, 0, 1000)
可以看到，有空行的代码，明显看起来更加舒适愉悦。在大家用汉语写作文的时候，老师一直教导我们要合理的使用标点符号，合理的分段。其实，写代码和写文章是一样的。在代码中，大家可以这样想象：换行是逗号，空一行是句号，空两行是分段。至于逗号，由于我们总是在一行中写一条语句，所以，逗号是可以忽略的，如果你在一行中写了多条语句，就好比在写作文的时候没有正确的使用逗号，也让人难以理解。如果你从来不空行，所有代码纠缠在一起，就好比没有句号，让人读起来很累，同理，不分段也不是 好习惯。
参考链接：https://www.zhihu.com/question/48755767/answer/130286487
在这篇回答中，我给出了很多Python优雅实现的例子，然后，讨论了如何才能写出优美的代码，希望对大家有帮助。
技术交流
欢迎转载、收藏、有所收获点赞支持一下！
目前开通了技术交流群，群友超过2000人，添加方式如下：
如下方式均可，添加时最好方式为：来源+兴趣方向，方便找到志同道合的朋友
- 方式一、发送如下图片至微信，进行长按识别，回复加群；
- 方式二、直接添加小助手微信号：pythoner666，备注：来自CSDN
- 方式三、微信搜索公众号：Python学习与数据挖掘，后台回复：加群
