[TOC]

Python内建了map()和reduce()函数。

如果你读过Google的那篇大名鼎鼎的论文“MapReduce: Simplified Data Processing on Large Clusters”，你就能大概明白map/reduce的概念。

map

map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

1

map(fun, Iteratble)

举例说明，比如我们有一个函数f(x) = x * x，要把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

            f(x) = x * x
                  │
                  │
  ┌───┬───┬───┬───┼───┬───┬───┬───┐
  │   │   │   │   │   │   │   │   │
  ▼   ▼   ▼   ▼   ▼   ▼   ▼   ▼   ▼

[ 1   2   3   4   5   6   7   8   9 ]

  │   │   │   │   │   │   │   │   │
  │   │   │   │   │   │   │   │   │
  ▼   ▼   ▼   ▼   ▼   ▼   ▼   ▼   ▼

[ 1   4   9  16  25  36  49  64  81 ]

现在，我们用Python代码实现：

1
2
3
4
5
6

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

map()传入的第一个参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。

你可能会想，不需要map()函数，写一个循环，也可以计算出结果：

1
2
3
4

L = []
for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
    L.append(f(n))
print(L)

的确可以，但是，从上面的循环代码，能一眼看明白“把f(x)作用在list的每一个元素并把结果生成一个新的list”吗？

所以，map()作为高阶函数，事实上它把运算规则抽象了，因此，我们不但可以计算简单的f(x) = x * x，还可以计算任意复杂的函数，比如，把这个list所有数字转为字符串：

1
2

>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

只需要一行代码。

reduce

reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：

1

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

比方说对一个序列求和，就可以用reduce实现：

1
2
3
4
5
6
7

>>> from functools import reduce
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

当然求和运算可以直接用Python内建函数sum()，没必要动用reduce。

但是如果要把序列[1, 3, 5, 7, 9]变换成整数13579，reduce就可以派上用场：

1
2
3
4
5
6
7

>>> from functools import reduce
>>> def fn(x, y):
...     return x * 10 + y
...
>>> reduce(fn, [1, 3, 5, 7, 9])
13579

map + reduce

这个例子本身没多大用处，但是，如果考虑到字符串str也是一个序列，对上面的例子稍加改动，配合map()，我们就可以写出把str转换为int的函数：

1
2
3
4
5
6
7
8
9
10
11

>>> from functools import reduce
>>> def fn(x, y):
...     return x * 10 + y
...
>>> def char2num(s):
...     digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
...     return digits[s]
...
>>> reduce(fn, map(char2num, '13579'))
13579

整理成一个str2int的函数就是：

1
2
3
4
5
6
7
8
9
10
11

from functools import reduce

DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}

def str2int(s):
    def fn(x, y):
        return x * 10 + y
    def char2num(s):
        return DIGITS[s]
    return reduce(fn, map(char2num, s))

还可以用lambda函数进一步简化成：

1
2
3
4
5
6
7
8
9
10

from functools import reduce

DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}

def char2num(s):
    return DIGITS[s]

def str2int(s):
    return reduce(lambda x, y: x * 10 + y, map(char2num, s))

也就是说，假设Python没有提供int()函数，你完全可以自己写一个把字符串转化为整数的函数，而且只需要几行代码！

try it ?

1.利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']：

1
2
3
4
5
6
7

def fun(L):
    return L[0].upper() + L[1:].lower()

if __name__ == '__main__':
    L1 = ['adam', 'LISA', 'barT']
    L2 = list(map(fun, L1))
    print(L2)

2.Python提供的sum()函数可以接受一个list并求和，请编写一个prod()函数，可以接受一个list并利用reduce()求积：

1
2
3
4
5
6

from functools import reduce
def prod(L):
    return reduce(lambda x,y : x * y, L)
    pass
if __name__ == '__main__':
    print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9])))    

3.利用map和reduce编写一个str2float函数，把字符串'123.456'转换成浮点数123.456：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# -*- coding: utf-8 -*-
from functools import reduce

DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, '.': '.'}

turn = False
f = 1
def fn(x, y):
    global turn, f
    if y == '.' :
        turn = True
        return x
    elif turn == False :
        return x * 10 + y
    else:
        f = f * 10
        return x  + y/f

def char2num(s):
    return DIGITS[s]

def str2float(s):
    return reduce(fn, map(char2num, s))
if __name__ == '__main__':
    print(str2float('123.4567'))

[TOC]

高阶函数

高阶函数英文叫Higher-order function。把函数作为参数传入，这样的函数称为高阶函数，编写高阶函数，就是让函数的参数能够接收别的函数。

变量可以指向函数

以Python内置的求绝对值的函数abs()为例，调用该函数用以下代码：

1
2
3

>>> abs(-10)
10

但是，如果只写abs呢？

1
2
3

>>> abs
<built-in function abs>

可见，abs(-10)是函数调用，而abs是函数本身。

要获得函数调用结果，我们可以把结果赋值给变量：

1
2
3
4

>>> x = abs(-10)
>>> x
10

但是，如果把函数本身赋值给变量呢？

1
2
3
4

>>> f = abs
>>> f
<built-in function abs>

结论：函数本身也可以赋值给变量，即：变量可以指向函数。

如果一个变量指向了一个函数，那么，可否通过该变量来调用这个函数？用代码验证一下：

1
2
3
4

>>> f = abs
>>> f(-10)
10

成功！说明变量f现在已经指向了abs函数本身。直接调用abs()函数和调用变量f()完全相同。

函数名也是变量

那么函数名是什么呢？函数名其实就是指向函数的变量！对于abs()这个函数，完全可以把函数名abs看成变量，它指向一个可以计算绝对值的函数！

如果把abs指向其他对象，会有什么情况发生？

1
2
3
4
5
6

>>> abs = 10
>>> abs(-10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable

把abs指向10后，就无法通过abs(-10)调用该函数了！因为abs这个变量已经不指向求绝对值函数而是指向一个整数10！

当然实际代码绝对不能这么写，这里是为了说明函数名也是变量。要恢复abs函数，请重启Python交互环境。

注：由于abs函数实际上是定义在import builtins模块中的，所以要让修改abs变量的指向在其它模块也生效，要用import builtins; builtins.abs = 10。

传入函数

既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

一个最简单的高阶函数：

1
2
3

def add(x, y, f):
    return f(x) + f(y)

当我们调用add(-5, 6, abs)时，参数x，y和f分别接收-5，6和abs，根据函数定义，我们可以推导计算过程为：

1
2
3
4
5

x = -5
y = 6
f = abs
f(x) + f(y) ==> abs(-5) + abs(6) ==> 11
return 11

[TOC]

1.lambda

Python 内置函数

描述

python 使用 lambda 来创建匿名函数。

语法

lambda 函数的语法只包含一个语句，如下：

1

lambda [arg1 [,arg2,.....argn]]:expression

注意

1
2

lambda (x, y): x + y
# tuple parameter unpacking is not supported in python3

这样的使用在python3中已经被废弃了，会提示上面注释中的错误

那么元组tuple如何作为参数呢，will be translated into:

1
2

lambda x_y: x_y[0] + x_y[1]
# 即在传入参数的时候，整个变量作为元组的参数，使用的时候，引用整个元组的位置参数

2.map()

Python 内置函数

描述

map() 会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

语法

map() 函数语法：

1

map(function, iterable, ...)

参数

• function – 函数，有两个参数
• iterable – 一个或多个序列

返回值

Python 2.x 返回列表。

Python 3.x 返回迭代器。

注意

1
2
3
4

def f(x, y): return (x, y)
l1 = [ 0, 1, 2, 3, 4, 5, 6 ]
l2 = [ 'Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat' ]

在python2中：

1
2

map(f, l1, l2)  
[(0, 'Sun'), (1, 'Mon'), (2, 'Tue'), (3, 'Wed'), (4, 'Thu'), (5, 'Fri'), (6, 'Sat')]  

在python3中：

1
2
3
4
5
6

map(f, l1, l2)  
<map object at 0x000001B5C5B79198>
# python3 map返回的是一个iterable
# 所以在python3中要记得把iterable给list化
list(map(f, l1, l2))
[(0, 'Sun'), (1, 'Mon'), (2, 'Tue'), (3, 'Wed'), (4, 'Thu'), (5, 'Fri'), (6, 'Sat')]

3.reduce()

描述

reduce() 函数会对参数序列中元素进行累积。

函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

语法

reduce() 函数语法：

1

reduce(function, iterable[, initializer])

参数

• function – 函数，有两个参数
• iterable – 可迭代对象
• initializer – 可选，初始参数

返回值

返回函数计算结果。

在 Python3 中，reduce() 函数已经被从全局名字空间里移除了，它现在被放置在 fucntools 模块里，如果想要使用它，则需要通过引入 functools 模块来调用 reduce() 函数：

1

from functools import reduce

实例：

1
2
3
4

from functools import reduce
def add(x,y):
    return x + y
print (reduce(add, range(1, 101)))

输出结果为：

1

5050

[TOC]

setuptools

setuptools 是一个优秀的，可靠的 Pthon 包安装与分发工具。

包格式

Python 库打包的格式包括 Wheel 和 Egg。Egg 格式是由 setuptools 在 2004 年引入，而 Wheel 格式是由 PEP427 在 2012 年定义。使用 Wheel 和 Egg 安装都不需要重新构建和编译，其在发布之前就应该完成测试和构建。

Egg 和 Wheel 本质上都是一个 zip 格式包，Egg 文件使用 .egg 扩展名，Wheel 使用 .whl 扩展名。Wheel 的出现是为了替代 Egg，其现在被认为是 Python 的二进制包的标准格式。

以下是 Wheel 和 Egg 的主要区别：

• Wheel 有一个官方的 PEP427 来定义，而 Egg 没有 PEP 定义
• Wheel 是一种分发格式，即打包格式。而 Egg 既是一种分发格式，也是一种运行时安装的格式，并且是可以被直接 import
• Wheel 文件不会包含 .pyc 文件
• Wheel 使用和 PEP376 兼容的 .dist-info 目录，而 Egg 使用 .egg-info 目录
• Wheel 有着更丰富的命名规则。
• Wheel 是有版本的。每个 Wheel 文件都包含 wheel 规范的版本和打包的实现
• Wheel 在内部被 sysconfig path type 管理，因此转向其他格式也更容易

详细描述可见：Wheel vs Egg

一个包的内容通常会保存在一个目录下（通常也会把子包分离在不同的文件目录下）, 根目录包含了各种各样的配置文件（setup.py 是一个必须的并且最重要的配置文件），代码本身通常在一个子目录（如：facedetect）下，目录名就是包的名称。当然最好还有一个测试文件目录。

下面就是 “facedetect” 的目录结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

> tree

.
├── LICENSE
├── MANIFEST.in
├── README.md
├── prepare.sh
├── requirements.txt
├── facedetect
│   ├── det1.npy
│   ├── det2.npy
│   ├── det3.npy
│   ├── detect_face.py
│   ├── facedata.py
│   ├── facenet.py
│   ├── face.py
│   ├── face_quality_anger.py
│   ├── __init__.py
│   ├── models
│   │   ├── ...
│   │   └── models.pb
│   └──keyPoints.py
├── setup.py
├── setup.cfg
├── setup_test.py
├── tests
│   ├── face_quality_anger_test.py
│   └── face_test.py
│   ├── detect_face_test.py
│   ├── facedata_test.py
│   └── facenet_test.py
└── tox.ini

Setup.py

setup.py 文件中导入了两个函数：setup() 和find_packages()。然后调用了 setup()，并且将 find_packages() 作为其中的一个参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

from setuptools import setup, find_packages

requirements = ['numpy', 'tensorflow', 'opencv-python', 'Keras', 'scipy', 'requests', 'h5py', 'pandas', 'imutils', 'torch']
setup(
    name="facedetect",
    version="2.3",
    description='facedetect description',
    long_description=open('README.md').read(),
    url='https://www.example.com',
    author='superman',
    author_email='hooby.example.com',
    python_requires='>=3.5.4',
    packages=find_packages(),
    install_requires=requirements,
    exclude_package_date={'': ['.gitignore'],
                          'facedetect': ['.idea/*', '__pycache__/*']},
    include_package_data=True,
)

参数概述

setup 函数常用的参数如下：

更多参数可见：https://setuptools.readthedocs.io/en/latest/setuptools.html

find_packages

对于简单工程来说，手动增加 packages 参数是容易。而对于复杂的工程来说，可能添加很多的包，这是手动添加就变得麻烦。Setuptools 模块提供了一个 find_packages 函数,它默认在与 setup.py 文件同一目录下搜索各个含有 __init__.py 的目录做为要添加的包。

1

find_packages(where='.', exclude=(), include=('*',))

find_packages 函数的第一个参数用于指定在哪个目录下搜索包，参数 exclude 用于指定排除哪些包，参数 include 指出要包含的包。

默认默认情况下 setup.py 文件只在其所在的目录下搜索包。如果不用 find_packages，想要找到其他目录下的包，也可以设置 package_dir 参数，其指定哪些目录下的文件被映射到哪个源码包，如: package_dir={'': 'src'} 表示 “root package” 中的模块都在 src 目录中。

包含数据文件

• package_data:

该参数是一个从包名称到 glob 模式列表的字典。如果数据文件包含在包的子目录中，则 glob 可以包括子目录名称。其格式一般为 {‘package_name’: [‘files’]}，比如：package_data={'mypkg': ['data/*.dat'],}。

• include_package_data:

该参数被设置为 True 时自动添加包中受版本控制的数据文件，可替代 package_data，同时，exclude_package_data 可以排除某些文件。注意当需要加入没有被版本控制的文件时，还是仍然需要使用 package_data 参数才行。

• exclude_package_data

  字典中，key值为：”“， 表示当前目录。

  1 2	exclude_package_date={'': ['.gitignore'], 'facedetect': ['.idea/*', '__pycache__/*']}

• data_files:

该参数通常用于包含不在包内的数据文件，即包的外部文件，如：配置文件，消息目录，数据文件。其指定了一系列二元组，即(目的安装目录，源文件) ，表示哪些文件被安装到哪些目录中。如果目录名是相对路径，则相对于安装前缀进行解释。

• manifest template:

manifest template 即编写 MANIFEST.in 文件，文件内容就是需要包含在分发包中的文件。一个 MANIFEST.in 文件如下：

1
2
3

include *.txt
recursive-include examples *.txt *.py
prune examples/sample?/build

MANIFEST.in 文件的编写规则可参考：https://docs.python.org/3.6/distutils/sourcedist.html

生成脚本

有两个参数 scripts 参数或 console_scripts 可用于生成脚本。

entry_points 参数用来支持自动生成脚本，其值应该为是一个字典，从 entry_point 组名映射到一个表示 entry_point 的字符串或字符串列表，如：

1
2
3
4
5
6
7
8
9

setup(
    # other arguments here...
    entry_points={
        'console_scripts': [
            'foo=foo.entry:main',
            'bar=foo.entry:main',
        ],    
    }
)

scripts 参数是一个 list，安装包时在该参数中列出的文件会被安装到系统 PATH 路径下。如：

1

scripts=['bin/foo.sh', 'bar.py']

用如下方法可以将脚本重命名，例如去掉脚本文件的扩展名(.py、.sh):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

from setuptools.command.install_scripts import install_scripts

class InstallScripts(install_scripts):

    def run(self):
        setuptools.command.install_scripts.install_scripts.run(self)

        # Rename some script files
        for script in self.get_outputs():
            if basename.endswith(".py") or basename.endswith(".sh"):
                dest = script[:-3]
            else:
                continue
            print("moving %s to %s" % (script, dest))
            shutil.move(script, dest)

setup(
    # other arguments here...
    cmdclass={
        "install_scripts": InstallScripts
    }
)

其中，cmdclass 参数表示自定制命令，后文详述。

ext_modules

ext_modules 参数用于构建 C 和 C++ 扩展扩展包。其是 Extension 实例的列表，每一个 Extension 实例描述了一个独立的扩展模块，扩展模块可以设置扩展包名，头文件、源文件、链接库及其路径、宏定义和编辑参数等。如：

1
2
3
4
5
6
7
8
9

setup(
    # other arguments here...
    ext_modules=[
        Extension('foo',
                  glob(path.join(here, 'src', '*.c')),
                  libraries = [ 'rt' ],
                  include_dirs=[numpy.get_include()])
    ]
)

详细了解可参考：https://docs.python.org/3.6/distutils/setupscript.html#preprocessor-options

zip_safe

zip_safe 参数决定包是否作为一个 zip 压缩后的 egg 文件安装，还是作为一个以 .egg 结尾的目录安装。因为有些工具不支持 zip 压缩文件，而且压缩后的包也不方便调试，所以建议将其设为 False，即 zip_safe=False。

自定义命令

Setup.py 文件有很多内置的的命令，可以使用 python setup.py --help-commands 查看。如果想要定制自己需要的命令，可以添加 cmdclass 参数，其值为一个 dict。实现自定义命名需要继承 setuptools.Command 或者 distutils.core.Command 并重写 run 方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

from setuptools import setup, Command

class InstallCommand(Command):
    description = "Installs the foo."
    user_options = [
        ('foo=', None, 'Specify the foo to bar.'),
    ]
    def initialize_options(self):
        self.foo = None
    def finalize_options(self):
        assert self.foo in (None, 'myFoo', 'myFoo2'), 'Invalid foo!'
    def run(self):
        install_all_the_things()

setup(
    ...,
    cmdclass={
        'install': InstallCommand,
    }
)

依赖关系

如果包依赖其他的包，可以指定 install_requires 参数，其值为一个 list，如：

1
2
3
4

install_requires=[
    'requests>=1.0',
    'flask>=1.0'
]

指定该参数后，在安装包时会自定从 pypi 仓库中下载指定的依赖包安装。

此外，还支持从指定链接下载依赖，即指定 dependency_links 参数，如：

1
2
3
4

dependency_links = [
    "http://packages.example.com/snapshots/foo-1.0.tar.gz",
    "http://example2.com/p/bar-1.0.tar.gz",
]

分类信息

classifiers 参数说明包的分类信息。所有支持的分类列表见：https://pypi.org/pypi?%3Aaction=list_classifiers

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

classifiers = [
    # 发展时期,常见的如下
    #   3 - Alpha
    #   4 - Beta
    #   5 - Production/Stable
    'Development Status :: 3 - Alpha',

    # 开发的目标用户
    'Intended Audience :: Developers',

    # 属于什么类型
    'Topic :: Software Development :: Build Tools',

    # 许可证信息
    'License :: OSI Approved :: MIT License',

    # 目标 Python 版本
    'Programming Language :: Python :: 2',
    'Programming Language :: Python :: 2.7',
    'Programming Language :: Python :: 3',
    'Programming Language :: Python :: 3.3',
    'Programming Language :: Python :: 3.4',
    'Programming Language :: Python :: 3.5',
]

Setup.cfg

setup.cfg 是一个 ini 格式的文件，文件用于提供 setup.py 的默认参数，详细的书写规则可参考：https://docs.python.org/3/distutils/configfile.html

MANIFEST.in

此文件中包含有不属于内部包目录，但你仍想纳入进来的文件。这些文件通常是 readme 文件，license 文件以及一些类似的文件。其中，比较重要的一个是 requirements.txt。 pip 使用该文件安装其他必须的包。

上面facedetect目录下的npy文件和models目录默认是不会被打包的。

1
2
3
4
5
6
7

include LICENSE
include README.md
include requirements.txt
include facedetect/det1.npy
include facedetect/det2.npy
include facedetect/det3.npy
recursive-include facedetect/models *

MANIFEST.in 文件的编写规则可参考：https://docs.python.org/3.6/distutils/sourcedist.html

版本命名

包版本的命名格式应为如下形式:

1

N.N[.N]+[{a|b|c|rc}N[.N]+][.postN][.devN]

从左向右做一个简单的解释：

• “N.N”: 必须的部分，两个 “N” 分别代表了主版本和副版本号

• “[.N]”: 次要版本号，可以有零或多个

• “{a|b|c|rc}”: 阶段代号，可选, a, b, c, rc 分别代表 alpha, beta, candidate 和 release candidate

• “N[.N]”: 阶段版本号，如果提供，则至少有一位主版本号，后面可以加无限多位的副版本号

• “.postN”: 发行后更新版本号，可选

• “.devN”: 开发期间的发行版本号，可选

easy_install 与 pip

easy_insall 是 setuptool 包提供的第三方包安装工具，而 pip 是 Python 中一个功能完备的包管理工具，是 easy_install 的改进版，提供更好的提示信息，删除包等功能。

pip 相对于 easy_install 进行了以下几个方面的改进:

• 所有的包是在安装之前就下载了，所以不可能出现只安装了一部分的情况
• 在终端上的输出更加友好
• 对于动作的原因进行持续的跟踪。例如，如果一个包正在安装，那么 pip 就会跟踪为什么这个包会被安装
• 错误信息会非常有用
• 代码简洁精悍可以很好的编程
• 不必作为 egg 存档，能扁平化安装(仍然保存 egg 元数据)
• 原生的支持其他版本控制系统(Git, Mercurial and Bazaar)
• 加入卸载包功能
• 可以简单的定义修改一系列的安装依赖，还可以可靠的赋值一系列依赖包

发布包

PyPI(Python Package Index) 是 Python 官方维护的第三方包仓库，用于统一存储和管理开发者发布的 Python 包。

如果要发布自己的包，需要先到 pypi 上注册账号。然后创建 ~/.pypirc 文件，此文件中配置 PyPI 访问地址和账号。如的.pypirc文件内容请根据自己的账号来修改。

典型的 .pypirc 文件

1
2
3
4
5
6

[distutils]
index-servers = pypi

[pypi]
username:xxx
password:xxx

接着注册项目：

python setup.py register

该命令在 PyPi 上注册项目信息，成功注册之后，可以在 PyPi 上看到项目信息。最后构建源码包发布即可：

python setup.py sdist upload

安装并执行

• 安装：python setup.py install
  另外：

• 执行：python setup.py sdist会在dist文件夹生成项目的压缩包

• 执行：python setup.py bdist_wininst会生成exe安装文件

参考资料

http://blog.konghy.cn/2018/04/29/setup-dot-py/#part-2cf9acb6815af000

https://sdk.cn/news/4647

[TOC]

函数式编程概念

函数式编程就是指高度抽象的编程范式。

函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。

而函数式编程（请注意多了一个“式”字）——Functional Programming，虽然也可以归结到面向过程的程序设计，但其思想更接近数学计算。

我们首先要搞明白计算机（Computer）和计算（Compute）的概念。

在计算机的层次上，CPU执行的是加减乘除的指令代码，以及各种条件判断和跳转指令，所以，汇编语言是最贴近计算机的语言。

而计算则指数学意义上的计算，越是抽象的计算，离计算机硬件越远。

对应到编程语言，就是越低级的语言，越贴近计算机，抽象程度低，执行效率高，比如C语言；越高级的语言，越贴近计算，抽象程度高，执行效率低，比如Lisp语言。

函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。

函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！

Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。

函数式编程内容

Python里面的函数式编程有:

1.高阶函数

2.返回函数

3.匿名函数

4.装饰器

5.偏函数

…

后面会吧这几个分别写出来.

[TOC]

sort or sorted ?

1
2
3
4
5

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

list.sorted的用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

sorted(iterable)
----------------------------------------------------------------------------------
>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a)       # 保留原列表
>>> a 
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]
----------------------------------------------------------------------------------

sorted(iterable, cmp)
sorted(iterable, key)
sorted(iterable, cmp, key)
sorted(iterable, cmp, key, reverse=False)

----------------------------------------------------------------------------------
>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2])            # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
 
>>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
----------------------------------------------------------------------------------

与list.sort 的使用

1
2
3
4
5
6
7
8
9
10

sort(self, key=None, reverse=False)

if __name__ == '__main__':

    a = [5, 7, 6, 3, 4, 1, 2]
    b = [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
    a.sort(reverse=True)
    print(a)
    b.sort(key=lambda x:x[0])
    print(b)

[TOC]

Iterable

我们已经知道，可以直接作用于for循环的数据类型有以下几种：

一类是集合数据类型，如list、tuple、dict、set、str等；

一类是generator，包括生成器和带yield的generator function。

这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。

可以使用isinstance()判断一个对象是否是Iterable对象：

1
2
3
4
5
6
7
8
9
10
11
12

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False

Iterator

而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

可以使用isinstance()判断一个对象是否是Iterator对象：

1
2
3
4
5
6
7
8
9
10

>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。

Iteratble转Iterator

把list、dict、str等Iterable变成Iterator可以使用iter()函数：

1
2
3
4
5

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

你可能会问，为什么list、dict、str等数据类型不是Iterator？

这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。

小结

凡是可作用于for循环的对象都是Iterable类型；

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的，例如：

1
2
3

for x in [1, 2, 3, 4, 5]:
    pass

实际上完全等价于：

1
2
3
4
5
6
7
8
9
10
11

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

[TOC]

Python 终端输出字体设置

shutil可以实现文件的复制，移动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 复制文件：
shutil.copyfile("oldfile","newfile") 
# oldfile和newfile都只能是文件

shutil.copy("oldfile","newfile") 
# oldfile只能是文件夹，newfile可以是文件，也可以是目标目录
 
# 复制文件夹：
shutil.copytree("olddir","newdir") 
# olddir和newdir都只能是目录，且newdir必须不存在
 
# 重命名文件（目录）
os.rename("oldname","newname") 
# 文件或目录都是使用这条命令
 
# 移动文件（目录）
shutil.move("oldpos","newpos") 

[TOC]

生成器(generator)

在生成列表的过程中，根据需要动态生成列表的机制成为生成器。

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

next()调用

要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

1
2
3
4
5
6

>>> L = [x * x for x in range(6)]
>>> L
[0, 1, 4, 9, 16, 25]
>>> g = (x * x for x in range(6))
>>> g
<generator object <genexpr> at 0x1022ef630>

创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

我们可以直接打印出list的每一个元素，但我们怎么打印出generator的每一个元素呢？

如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

我们讲过，generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

for调用

当然，上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环，因为generator也是可迭代对象：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)

0
1
4
9
16
25
36
49
64
81

所以，我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误。

yield

generator非常强大。如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。

比如，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：

1, 1, 2, 3, 5, 8, 13, 21, 34, …

斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易：

1
2
3
4
5
6
7

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

注意，赋值语句：

1
2

a, b = b, a + b

相当于：

1
2
3
4

t = (b, a + b) # t是一个tuple
a = t[0]
b = t[1]

但不必显式写出临时变量t就可以赋值。

上面的函数可以输出斐波那契数列的前N个数：

1
2
3
4
5
6
7
8
9

>>> fib(6)
1
1
2
3
5
8
'done'

仔细观察，可以看出，fib函数实际上是定义了斐波拉契数列的推算规则，可以从第一个元素开始，推算出后续任意的元素，这种逻辑其实非常类似generator。

也就是说，上面的函数和generator仅一步之遥。要把fib函数变成generator，只需要把print(b)改为yield b就可以了：

1
2
3
4
5
6
7

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator：

1
2
3

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

举个简单的例子，定义一个generator，依次返回数字1，3，5：

1
2
3
4
5
6
7

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)

调用该generator时，首先要生成一个generator对象，然后用next()函数不断获得下一个返回值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

>>> o = odd()
>>> next(o)
step 1
1
>>> next(o)
step 2
3
>>> next(o)
step 3
5
>>> next(o)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

可以看到，odd不是普通函数，而是generator，在执行过程中，遇到yield就中断，下次又继续执行。执行3次yield后，已经没有yield可以执行了，所以，第4次调用next(o)就报错。

回到fib的例子，我们在循环过程中不断调用yield，就会不断中断。当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来。

同样的，把函数改成generator后，我们基本上从来不会用next()来获取下一个返回值，而是直接使用for循环来迭代：

1
2
3
4
5
6
7
8
9

>>> for n in fib(6):
...     print(n)
...
1
1
2
3
5
8

但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

>>> g = fib(6)
>>> while True:
...     try:
...         x = next(g)
...         print('g:', x)
...     except StopIteration as e:
...         print('Generator return value:', e.value)
...         break
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done

关于如何捕获错误，后面的错误处理还会详细讲解。

练习

杨辉三角定义如下：

1
2
3
4
5
6
7
8
9
10
11

          1
         / \
        1   1
       / \ / \
      1   2   1
     / \ / \ / \
    1   3   3   1
   / \ / \ / \ / \
  1   4   6   4   1
 / \ / \ / \ / \ / \
1   5   10  10  5   1

把每一行看做一个list，试写一个generator，不断输出下一行的list：

1
2
3
4
5
6
7
8

# -*- coding: utf-8 -*-
def triangles():
    L = [1]
    while True:  
        yield L
        L = [1] + [L[i] + L[i + 1] for i in range(len(L) - 1)] + [1]
#目前个人理解，这里还是不要用while True的方式，如果程序有bug难道要一直给出输出吗？ 
#可以改成 for i in range(10000): 这样循环了一万次你还要数据就应该引起警觉了。可以根据需求修改这个值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# 期待输出:
# [1]
# [1, 1]
# [1, 2, 1]
# [1, 3, 3, 1]
# [1, 4, 6, 4, 1]
# [1, 5, 10, 10, 5, 1]
# [1, 6, 15, 20, 15, 6, 1]
# [1, 7, 21, 35, 35, 21, 7, 1]
# [1, 8, 28, 56, 70, 56, 28, 8, 1]
# [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
n = 0
results = []
for t in triangles():
    print(t)
    results.append(t)
    n = n + 1
    if n == 10:
        break
if results == [
    [1],
    [1, 1],
    [1, 2, 1],
    [1, 3, 3, 1],
    [1, 4, 6, 4, 1],
    [1, 5, 10, 10, 5, 1],
    [1, 6, 15, 20, 15, 6, 1],
    [1, 7, 21, 35, 35, 21, 7, 1],
    [1, 8, 28, 56, 70, 56, 28, 8, 1],
    [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
]:
    print('测试通过!')
else:
    print('测试失败!')

小结

generator是非常强大的工具，在Python中，可以简单地把列表生成式改成generator，也可以通过函数实现复杂逻辑的generator。

要理解generator的工作原理，它是在for循环的过程中不断计算出下一个元素，并在适当的条件结束for循环。对于函数改成的generator来说，遇到return语句或者执行到函数体最后一行语句，就是结束generator的指令，for循环随之结束。

请注意区分普通函数和generator函数，普通函数调用直接返回结果：

1
2
3

>>> r = abs(6)
>>> r
6

generator函数的“调用”实际返回一个generator对象：

1
2
3

>>> g = fib(6)
>>> g
<generator object fib at 0x1022ef948>

[TOC]

Python 终端输出字体设置

实现过程：

​ 终端的字符颜色是用转义序列控制的，是文本模式下的系统显示功能，和具体的语言无关。

​ 转义序列是以ESC开头,即用\033来完成（ESC的ASCII码用十进制表示是27，用八进制表示就是033）。

书写格式：

​ 开头部分：\033[显示方式;前景色;背景色m + 结尾部分：\033[m

​ 注意：开头部分的三个参数：显示方式，前景色，背景色是可选参数，可以只写其中的某一个；另外由于表示三个参数不同含义的数值都是唯一的没有重复的，所以三个参数的书写先后顺序没有固定要求，系统都能识别；但是，建议按照默认的格式规范书写。

​ 对于结尾部分，其实也可以省略，但是为了书写规范，建议\033[***开头，\033[0m结尾。很多人在结尾部分写成\033[0m，很多文章也是这么说，多半估计他们都是直接抄的别人的blog，其实连0 都是可以省略掉的，我自己试过没有问题。

那这些参数分别是什么值，又代表什么意思呢，请看下边的表，

数值表示的参数含义：

常见开头格式：
\033[m 默认字体正常显示，不高亮
\033[31m 红色字体正常显示
\033[1;32;40m 显示方式: 高亮 字体前景色：绿色 背景色：黑色
\033[31;46m 显示方式: 正常 字体前景色：红色 背景色：青色