Python 有哪些让你相见恨晚的技巧?

欢迎关注 ,专注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

三、优美的代码实现

在这一部分,我们会依次讨论一些美的代码。由于内容较多,所以,我进行了简单地分类,包括:

  1. 内置函数

  2. Python中的一些小细节

  3. 充分使用数据结构的便利性

  4. 合理使用Python的高级并发工具

  5. 巧妙使用装饰器简化代码

  6. Python中的设计模式

    Python 有哪些让你相见恨晚的技巧?_第1张图片

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程序员是幸福的。

四、如何写出优美(优雅)的代码

Python 有哪些让你相见恨晚的技巧?_第2张图片

关于这个问题,我想说的还有很多,然而,我编辑了好几天也没有编辑完。总是有个结束的时候,那就到此为止吧。

关于如何能够写出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学习与数据挖掘,后台回复:加群

在这里插入图片描述

你可能感兴趣的